home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / misc / emu / FrodoV1_5.lha / src / 6510.asm < prev    next >
Assembly Source File  |  1995-06-04  |  57KB  |  3,131 lines
  1. *
  2. * 6510.asm - 6510-Emulation (eigener Task)
  3. *
  4. * Copyright (C) 1994-1995 by Christian Bauer
  5. *
  6.  
  7. *
  8. * Anmerkungen:
  9. * ------------
  10. *
  11. * Register d0/d1 - WICHTIG:
  12. *  - Der Emulator geht davon aus, daß die MSWs von d0 und d1 immer Null
  13. *    sind. Denn dadurch kann das C64-RAM mittels (RAMPTR,d0.l) ohne
  14. *    Vorzeichen indiziert angesprochen werden.
  15. *  - Die Makros Read#?Zero#? und Read#?Ind#? gehen zusätlich davon aus,
  16. *    daß nur das untere Byte von d0 Null ist, da diese Makros immer nur
  17. *    am Anfang eines Befehls stehen und d0 vom Next-Makro noch gelöscht
  18. *    ist
  19. *
  20. * Speicherkonfigurationen:
  21. *
  22. * $01  $a000-$bfff  $d000-$dfff  $e000-$ffff
  23. * -----------------------------------------------
  24. *  0       RAM          RAM          RAM
  25. *  1       RAM       Char-ROM        RAM
  26. *  2       RAM       Char-ROM    Kernal-ROM
  27. *  3    Basic-ROM    Char-ROM    Kernal-ROM
  28. *  4       RAM          RAM          RAM
  29. *  5       RAM          I/O          RAM
  30. *  6       RAM          I/O      Kernal-ROM
  31. *  7    Basic-ROM       I/O      Kernal-ROM
  32. *
  33. * Zugriff auf den C64-Speicher:
  34. *  - Fast alle Speicherzugriffe laufen über die ReadByte/WriteByte-Makros,
  35. *    die die eingestellte Speicherkonfiguration dadurch berücksichtigen,
  36. *    daß die oberen 8 Adreßbits als Index in eine Sprungtabelle
  37. *    (ReadTab/WriteTab) dienen, die Zeiger auf die ReadByte*/WriteByte*-
  38. *    Routinen enthalten, über die der tatsächliche Zugriff erfolgt.
  39. *    Für jede der 8 Speicherkonfigurationen existiert jeweils eine solche
  40. *    Tabelle Bei einer Änderung der Speicherkonfiguration (NewConfig)
  41. *    werden die Zeiger auf die Tabellen (RDTAB/WRTAB) geändert.
  42. *  - Das LESEN aus der Zero-Page geschieht immer direkt,
  43. *    da dort keine Register liegen ($01 wird auch im RAM abgelegt)
  44. *  - Beim Schreiben in die Zero-Page wird nur auf $00/$01 getestet,
  45. *    ansonsten direkt zugegriffen
  46. *  - Der Stack wird immer direkt angesprochen
  47. *  - Die ReadByte-Routinen dürfen nur d0-d1/a0 verändern.
  48. *    a1 enthält die Rücksprungadresse, die Routinen müssen also mit
  49. *    "jmp (a1)" enden.
  50. *  - Die WriteByte-Routinen dürfen nur d0-d1/a0-a1 verändern
  51. *
  52. * Programmzähler:
  53. *  - Aus Geschwindigkeitsgründen wird der PC durch einen 32-Bit-
  54. *    Amiga-Zeiger repräsentiert und über diesen direkt auf den
  55. *    Speicher zugegriffen (und nicht über ReadByte). Bei einem
  56. *    Sprungbefehl wird aus dem 16-Bit Sprungziel und der aktuellen
  57. *    Speicherkonfiguration die neue 32-Bit-Adresse berechnet,
  58. *    indem ähnlich zur ReadTab die oberen 8 Bit des Sprungziels
  59. *    als Index in die JumpTab verwendet werden. Die darüber aufgerufenen
  60. *    Routinen führen die Umrechnung durch.
  61. *  - Durch die Art, wie das Hauptprogramm den Speicher anfordert,
  62. *    entsprechen die unteren 16 Bit des 32-Bit-PCs immer der
  63. *    16-Bit-C64-Adresse. Das erleichtert erheblich das Ablegen des
  64. *    PC auf dem Stack, da dazu einfach nur die unteren 16 Bit
  65. *    genommen werden müssen (ansonsten müßte man je nach RAM/ROM-
  66. *    Bereich erst die jeweilige Basisadresse subtrahieren).
  67. *  - Im RAM-Bereich $10000-$100ff wird der Opcode $d2 installiert,
  68. *    der den PC auf $0000-$00ff umrechnet, falls ein Programm den
  69. *    Wraparound macht
  70. *  - Durch diese Art der PC-Verwaltung bestehen folgende Inkompatibilitäten:
  71. *     - Ein Branch oder ein Hineinlaufen in einen anderen Speicherbereich
  72. *       (z.B. RAM->ROM) funktioniert nicht. Das sollte allerdings kein
  73. *       Problem darstellen.
  74. *     - Ein Sprung in den I/O-Bereich ist z.Z. nicht möglich
  75. *
  76. * Condition-Codes:
  77. *  - Die Emulation verwendet zwei Register, um die Prozessorflags zu
  78. *    speichern: RCCR und RP.
  79. *  - RCCR ist ein Abbild des 680x0-CCR und wird nach den entsprechenden
  80. *    Operationen mit "move ccr,RCCR" gelesen. Von RCCR werden nur das N-
  81. *    und das Z-Flag verwendet.
  82. *  - Die einzigen Opcodes, die V ändern, sind ADC, SBC, CLV, PLP und RTI.
  83. *    Darum wird das V-Flag nicht aus dem 680x0-V-Flag erzeugt, sondern
  84. *    gegebenenfalls von Hand gesetzt.
  85. *  - Im oberen Byte (Bit 8-15) von RP sind die 6510-Flags V,B,D und I
  86. *    in der selben Anordnung wie beim 6510 gespeichert. Das untere Byte
  87. *    enthält in Bit 0 das Carry-Flag in 6510-Interpretation (bei SBC und
  88. *    CMP/CPX/CPY inverse Bedeutung zum 680x0), das bei den entsprechenden
  89. *    Opcodes aus dem CCR gelesen (und ggf. invertiert) wird. Der Einfachheit
  90. *    halber wird immer das ganze untere Byte von CCR gelesen, da nur Bit 0
  91. *    interessant ist.
  92. *
  93. * Opcode-Ausführung:
  94. *  - Es gibt keine Fetch-Decode-Schleife, sondern jede Opcode-Routine
  95. *    enthält am Schluß den Code, der den nächsten Befehl ausführt
  96. *    ("Next"-Makro).
  97. *  - Die Verzweigung in die einzelnen Opcode-Routinen geschieht über
  98. *    eine Sprungtabelle, die OpcodeTable. Das Register OPTABPTR enthält
  99. *    einen Zeiger auf diese Tabelle (vor der Tabelle steht noch der
  100. *    Zyklenzähler, auf den so schneller zugegriffen werden kann).
  101. *
  102. * Zyklenzähler/Periodic/Interrupts:
  103. *  - Die Variable CyclesLeft (erreichbar über (OPTABPTR)) enthält die
  104. *    Anzahl Zyklen, die dem 6510 in der augenblicklichen Rasterzeile noch
  105. *    zur Verfügung stehen
  106. *  - Nach jeder Opcode-Ausführung wird dieser Zähler um die Zyklenzahl
  107. *    des gerade ausgeführten Befehls erniedrigt. Dazu wird dem Next-Makro
  108. *    die Anzahl Zyklen übergeben. Unterschreitet der Zähler Null, wird
  109. *    die Routine "Periodic" aufgerufen.
  110. *  - In dieser Routine werden die Unterroutinen von VIC und CIA
  111. *    ausgeführt, die die Aktionen für eine Rasterzeile durchführen
  112. *    (VIC (Periodic6569): Eine Bildschirmzeile aufbauen, CIA
  113. *    (Periodic6526): Timer zählen)
  114. *  - In Periodic6569 wird der Zyklenzähler neu gesetzt (der Wert hängt
  115. *    davon ab, ob eine Bad Line stattfand oder nicht)
  116. *
  117. * Interrupts:
  118. *  - Die Haupt-Interruptquellen sind VIC und CIA, daher prüft der
  119. *    Emulator das Auftreten eines Interrupts im Rahmen der Periodic-
  120. *    Routine
  121. *  - Es gibt folgende Interrupt-Möglichkeiten (Prioritäten):
  122. *     - RESET, Sprung nach ($FFFC) oder 6510-Task beenden (RESETIsEXIT-Flag)
  123. *     - NMI, Sprung nach ($FFFA)
  124. *     - VIC-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  125. *     - CIA-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  126. *  - Die Aufteilung in VIC- und CIA-IRQ erleichtert die Handhabung, wenn
  127. *    beide IRQs gleichzeitig auftreten
  128. *  - Die einzige Möglichkeit, außerhalb des Periodic einen Interrupt
  129. *    auszulösen, ist das Löschen des I-Flags, wenn ein IRQ ansteht.
  130. *    Die Opcode-Routinen für PLP, RTI und CLI enthalten deswegen besondere
  131. *    Abfragen, die ggf. in den Interrupt-Handler verzweigen.
  132. *
  133. * Erweiterungen:
  134. *  - Über den Opcode $f2 sind die 1541-Routinen implementiert. Dem Opcode
  135. *    folgt ein Byte, das die Nummer der auzurufenden Routine angibt.
  136. *
  137. * Inkompatibilitäten:
  138. *  - ($ff),Y-Adressierung liest das zweite Byte der indirekten Adresse
  139. *    aus $0100 statt $0000. Dies geschieht aus Geschwindigkeitsgründen,
  140. *    der korrekte Code ist im Makro ReadAdrIndY auskommentiert.
  141. *  - In der Verwaltung des PCs bestehen einige Ungenauigkeiten (siehe
  142. *    Abschnitt "Programmzähler")
  143. *  - RMW-Befehle sollten erst die Originaldaten und dann die geänderten
  144. *    schreiben, aber das spielt nur eine Rolle für Register wie das
  145. *    VIC-IRQFLAG-Register, das in 6569.asm deswegen speziell behandelt wird
  146. *  - Zyklen werden nur für ganze Befehle gezählt, Extra-Zyklen für
  147. *    Seitenüberschreitungen werden nicht berechnet (dies betrifft die
  148. *    Adressierungsarten xxxx,X xxxx,Y (xx),Y und die Branch-Befehle)
  149. *  - ADC und SBC im Dezimalmodus setzen die Flags nicht korrekt
  150. *  - RRA und ISB berücksichtigen das D-Flag nicht
  151. *
  152.  
  153.  
  154.         MACHINE    68020
  155.  
  156.         INCLUDE    "exec/types.i"
  157.         INCLUDE    "exec/macros.i"
  158.         INCLUDE    "exec/execbase.i"
  159.         INCLUDE    "exec/nodes.i"
  160.         INCLUDE    "dos/dos.i"
  161.         INCLUDE    "dos/dostags.i"
  162.         INCLUDE    "Frodo_rev.i"
  163. CATCOMP_NUMBERS    = 1
  164.         INCLUDE    "Strings.i"
  165.  
  166.         XREF    _SysBase
  167.         XREF    _DOSBase
  168.         XREF    _IntuitionBase
  169.  
  170.         XREF    GetString    ;Strings.o
  171.         XREF    TheLocale
  172.  
  173.         XDEF    TheRAM        ;Main.asm
  174.         XDEF    TheBasic
  175.         XDEF    TheKernal
  176.         XDEF    TheChar
  177.         XDEF    TheColor
  178.         XREF    MainTask
  179.         XREF    Random
  180.  
  181.         XREF    ReadFrom6526A    ;6526.asm
  182.         XREF    ReadFrom6526B
  183.         XREF    WriteTo6526A
  184.         XREF    WriteTo6526B
  185.         XREF    Reset6526
  186.  
  187.         XREF    Init6569    ;6569.asm
  188.         XREF    Exit6569
  189.         XREF    ReadFrom6569
  190.         XREF    WriteTo6569
  191.         XREF    Periodic6569
  192.         XREF    AmigaToFront
  193.         XREF    EmulToFront
  194.  
  195.         XREF    ReadFrom6581    ;6581.asm
  196.         XREF    WriteTo6581
  197.         XREF    Reset6581
  198.  
  199.         XREF    IECOut        ;1541.asm
  200.         XREF    IECOutATN
  201.         XREF    IECOutSec
  202.         XREF    IECIn
  203.         XREF    IECSetATN
  204.         XREF    IECRelATN
  205.         XREF    IECTurnaround
  206.         XREF    IECRelease
  207.  
  208.         XDEF    Init6510
  209.         XDEF    Start6510
  210.         XDEF    Stop6510
  211.         XDEF    Pause6510
  212.         XDEF    Resume6510
  213.         XDEF    Localize6510
  214.         XDEF    IntIsRESET
  215.         XDEF    IntIsNMI
  216.         XDEF    IntIsVICIRQ
  217.         XDEF    IntIsCIAIRQ
  218.         XDEF    CyclesLeft
  219.         XDEF    CPUTask
  220.         XDEF    Peri6569Cont
  221.         XDEF    Peri6526Cont
  222.  
  223.         SECTION    "CODE",CODE
  224.  
  225.  
  226. **
  227. ** Definitionen
  228. **
  229.  
  230. ; Bitdefinitionen für RP (6510-Statusregister)
  231. CarryBit    = 0    ;Carry (nach 6510-Definition)
  232. InterruptBit    = 10    ;Interrupts abgeschaltet
  233. InterruptMask    = $0400
  234. DecimalBit    = 11    ;Dezimalmodus
  235. DecimalMask    = $0800
  236. BreakBit    = 12    ;Break-Befehl (nur auf dem Stack)
  237. BreakMask    = $1000
  238. OverflowBit    = 14    ;Arith. Überlauf
  239. OverflowMask    = $4000
  240.  
  241. ; Registerbelegung (Achtung: In 1541.asm sind ebenfalls solche
  242. ;  Definitionen, die hiermit übereinstimmen müssen!)
  243. RA        EQUR    d2    ;A
  244. RX        EQUR    d3    ;X
  245. RY        EQUR    d4    ;Y
  246. RS        EQUR    d5    ;S (16-Bit, $01xx)
  247. RCCR        EQUR    d6    ;CCR, nur N und Z
  248. RP        EQUR    d7    ;Oberes Byte: 6510-Status ohne N,Z und C.
  249.                 ;Bit #0: Carry
  250. RDTAB        EQUR    a2    ;Zeiger auf ReadByte-Sprungtabelle
  251. WRTAB        EQUR    a3    ;Zeiger auf WriteByte-Sprungtabelle
  252.                 ;256*8*4+WRTAB zeigt auf JumpTab
  253. RAMPTR        EQUR    a4    ;Zeiger auf C64-RAM
  254. RPC        EQUR    a5    ;PC (32-Bit Amiga-Adresse, untere 16 Bit
  255.                 ;    stimmen mit C64-PC überein)
  256. OPTABPTR    EQUR    a6    ;Zeiger auf die Opcode-Dispatch-Tabelle
  257.                 ; und den Zyklenzähler
  258.  
  259.  
  260. *
  261. * Makros für Speicherzugriffe und Adreßberechnungen
  262. *
  263.  
  264. ; Ein C64-Byte lesen
  265. ; -> d0.w: Adresse
  266. ; <- d0.b: Byte
  267. ReadByte    MACRO
  268.         cmp.w    #$a000,d0    ;Unterhalb von $a000 ist nur Speicher
  269.         blo    \@1$
  270.         move.w    d0,d1
  271.         lsr.w    #8,d1
  272.         lea    \@2$(pc),a1    ;Ist hier schneller, weil sonst
  273.         move.l    (RDTAB,d1.w*4),a0 ;hinter dem jmp (a0) ein bra \@2$
  274.         jmp    (a0)        ;stehen müßte
  275. \@1$        move.b    (RAMPTR,d0.l),d0
  276. \@2$
  277.         ENDM
  278.  
  279. ; Ein C64-Wort lesen (Als Makro schneller)
  280. ; -> d0.w: Adresse
  281. ; <- d0.w: Wort (Bytefolge korrigiert)
  282. ReadWord    MACRO
  283.         move.l    d0,-(sp)    ;Adresse merken
  284.         ReadByte
  285.         move.b    d0,d1
  286.         move.l    (sp)+,d0    ;Adresse zurückholen
  287.         addq.w    #1,d0        ;Nächstes Byte
  288.         move.l    d1,-(sp)    ;Lo-Byte merken
  289.         ReadByte
  290.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  291.         move.l    (sp)+,d1
  292.         move.b    d1,d0        ;Lo-Byte dazunehmen
  293.         ENDM
  294.  
  295. ; Ein C64-Byte schreiben
  296. ; -> d0.w: Adresse (16 bit)
  297. ; -> d1.b: Byte
  298. ; Adresse steht dann in a1
  299. WriteByte    MACRO
  300.         cmp.w    #$a000,d0
  301.         blo    \@1$
  302.         move.l    d0,a1
  303.         lsr.w    #8,d0
  304.         move.l    (WRTAB,d0.w*4),a0
  305.         jsr    (a0)
  306.         bra    \@2$
  307. \@1$        move.b    d1,(RAMPTR,d0.l)
  308.         cmp.b    #2,d0
  309.         bhs    \@2$
  310.         NewConfig
  311. \@2$
  312.         ENDM
  313.  
  314. ; Ein C64-Wort am PC lesen und PC erhöhen
  315. ReadPCWord    MACRO
  316.         move.w    (RPC)+,d0
  317.         rol.w    #8,d0
  318.         ENDM
  319.  
  320. ; Relative Adressierung
  321. ReadByteRel    MACRO
  322.         move.b    (RPC)+,d0
  323.         ext.w    d0
  324.         ENDM
  325.  
  326. ; Absolute Adressierung
  327. ReadAdrAbs    MACRO
  328.         ReadPCWord
  329.         ENDM
  330.  
  331. ReadByteAbs    MACRO
  332.         ReadAdrAbs
  333.         ReadByte
  334.         ENDM
  335.  
  336. ; Indirekte Adressierung
  337. ReadAdrInd    MACRO
  338.         ReadPCWord
  339.         move.l    d0,-(sp)    ;Adresse merken
  340.         ReadByte
  341.         move.b    d0,d1
  342.         move.l    (sp)+,d0    ;Adresse zurückholen
  343.         addq.b    #1,d0        ;Nächstes Byte OHNE Page-Crossing
  344.         move.l    d1,-(sp)    ;Lo-Byte merken
  345.         ReadByte
  346.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  347.         move.l    (sp)+,d1
  348.         move.b    d1,d0        ;Lo-Byte dazunehmen
  349.         ENDM
  350.  
  351. ; Zero-Page Adressierung
  352. ReadAdrZero    MACRO
  353.         move.b    (RPC)+,d0
  354.         ENDM
  355.  
  356. ReadByteZero    MACRO    ;Register
  357.         ReadAdrZero
  358.         move.b    (RAMPTR,d0.w),\1
  359.         ENDM
  360.  
  361. ; Absolut,X
  362. ReadAdrAbsX    MACRO
  363.         ReadPCWord
  364.         add.w    RX,d0
  365.         ENDM
  366.  
  367. ReadByteAbsX    MACRO
  368.         ReadAdrAbsX
  369.         ReadByte
  370.         ENDM
  371.  
  372. ; Absolut,Y
  373. ReadAdrAbsY    MACRO
  374.         ReadPCWord
  375.         add.w    RY,d0
  376.         ENDM
  377.  
  378. ReadByteAbsY    MACRO
  379.         ReadAdrAbsY
  380.         ReadByte
  381.         ENDM
  382.  
  383. ; Zero-Page,X
  384. ReadAdrZeroX    MACRO
  385.         move.b    (RPC)+,d0
  386.         add.b    RX,d0
  387.         ENDM
  388.  
  389. ReadByteZeroX    MACRO    ;Register
  390.         ReadAdrZeroX
  391.         move.b    (RAMPTR,d0.w),\1
  392.         ENDM
  393.  
  394. ; Zero-Page,Y
  395. ReadAdrZeroY    MACRO
  396.         move.b    (RPC)+,d0
  397.         add.b    RY,d0
  398.         ENDM
  399.  
  400. ReadByteZeroY    MACRO    ;Register
  401.         ReadAdrZeroY
  402.         move.b    (RAMPTR,d0.w),\1
  403.         ENDM
  404.  
  405. ; (Ind,X)
  406. ReadAdrIndX    MACRO
  407.         move.b    (RPC)+,d0
  408.         add.b    RX,d0
  409.         move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  410.         addq.b    #1,d0
  411.         move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  412.         lsl.w    #8,d0
  413.         move.b    d1,d0            ;LSB einfügen
  414.         ENDM
  415.  
  416. ReadByteIndX    MACRO
  417.         ReadAdrIndX
  418.         ReadByte
  419.         ENDM
  420.  
  421. ; (Ind),Y
  422. ReadAdrIndY    MACRO
  423.         move.b    (RPC)+,d0
  424.  
  425. ;(Korrekt)    move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  426. ;        addq.b    #1,d0
  427. ;        move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  428. ;        lsl.w    #8,d0
  429. ;        move.b    d1,d0            ;LSB einfügen
  430.  
  431.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  432.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  433.  
  434.         add.w    RY,d0
  435.         ENDM
  436.  
  437. ReadByteIndY    MACRO
  438.         ReadAdrIndY
  439.         ReadByte
  440.         ENDM
  441.  
  442. ; Ein Byte (Arg1) auf den Stapel schieben
  443. PushByte    MACRO    ;Register
  444.         move.b    \1,(RAMPTR,RS.w)
  445.         subq.b    #1,RS
  446.         ENDM
  447.  
  448. ; PC auf Stack schieben
  449. PushPC        MACRO
  450.         move.w    RPC,d0
  451.         move.w    d0,d1
  452.         lsr.w    #8,d0
  453.         PushByte d0
  454.         PushByte d1
  455.         ENDM
  456.  
  457. ; PC+1 auf den Stack schieben
  458. PushPCPlus1    MACRO
  459.         move.w    RPC,d0
  460.         addq.w    #1,d0
  461.         move.w    d0,d1
  462.         lsr.w    #8,d0
  463.         PushByte    d0
  464.         PushByte    d1
  465.         ENDM
  466.  
  467. ; Status auf Stack schieben
  468. PushP        MACRO
  469.         move.w    RP,d0        ;6510-Status holen
  470.         lsr.w    #8,d0
  471.         and.b    #$5c,d0        ;V,B,D,I behalten
  472.         or.b    #$20,d0        ;1-Bit setzen
  473.         btst    #CarryBit,RP    ;C dazunehmen
  474.         beq    \@1$
  475.         or.b    #$01,d0
  476. \@1$        btst    #3,RCCR        ;N dazunehmen
  477.         beq    \@2$
  478.         or.b    #$80,d0
  479. \@2$        btst    #2,RCCR        ;Z dazunehmen
  480.         beq    \@3$
  481.         or.b    #$02,d0
  482. \@3$        PushByte d0
  483.         ENDM
  484.  
  485. ; Ein Byte vom Stapel nach Arg1 lesen
  486. PopByte        MACRO    ;Register
  487.         addq.b    #1,RS
  488.         move.b    (RAMPTR,RS.w),\1
  489.         ENDM
  490.  
  491. ; Status vom Stack holen
  492. PopP        MACRO
  493.         PopByte    d0
  494.         move    ccr,RCCR
  495.         and.b    #$08,RCCR    ;N holen
  496.         move.b    d0,RP
  497.         and.b    #$4c,RP        ;V,D,I behalten
  498.         lsl.w    #8,RP
  499.         btst    #1,d0        ;Z holen
  500.         beq    \@1$
  501.         or.b    #$04,RCCR
  502. \@1$        btst    #0,d0        ;C holen
  503.         beq    \@2$
  504.         or.b    #$01,RP
  505. \@2$
  506.         ENDM
  507.  
  508. ; PC setzen
  509. ; -> d0.w: 16-Bit-Adresse
  510. ; <- RPC.l: Amiga-Adresse
  511. Jump        MACRO
  512.         move.w    d0,d1
  513.         lsr.w    #8,d1
  514.         move.l    256*8*4(WRTAB,d1.w*4),a0
  515.         jsr    (a0)
  516.         ENDM
  517.  
  518. ; Nächsten Befehl ausführen
  519. Next        MACRO    ;Zyklenzahl
  520.     IFNE    \1
  521.         subq.w    #\1,(OPTABPTR)    ;Anzahl Zyklen abziehen
  522.         bmi    Periodic    ;Alle verbraucht: Periodic
  523.     ENDC
  524.  
  525.         moveq    #0,d0
  526.         move.b    (RPC)+,d0    ;Opcode lesen
  527.         move.l    4(OPTABPTR,d0.w*4),a0 ;Zeiger auf die Opcode-Routine holen
  528.         jmp    (a0)        ;Routine aufrufen
  529.         ENDM
  530.  
  531. ; Speicherkonfiguration anpassen
  532. NewConfig    MACRO
  533.         move.b    1(RAMPTR),d0    ;Config lesen
  534.         and.w    #7,d0        ;Relevante Bits maskieren
  535.         movem.l    (ConfigTab,pc,d0.w*8),RDTAB/WRTAB
  536.         ENDM
  537.  
  538. ; Ein C64-Byte in die Zero-Page schreiben und nächsten Befehl ausführen.
  539. ; Prüfen, ob sich die Speicherkonfiguration geändert hat.
  540. ; -> d0.w: Adresse (16 bit)
  541. ; -> Arg1: Byte
  542. WriteZeroNext    MACRO    ;Register, Zyklenzahl
  543.         move.b    \1,(RAMPTR,d0.w)
  544.         cmp.b    #2,d0
  545.         bhs    \@1$
  546.         NewConfig
  547. \@1$        Next    \2
  548.         ENDM
  549.  
  550.  
  551. **
  552. ** Emulation vorbereiten (Sprungtabellen aufbauen)
  553. **
  554.  
  555. ; ReadTabs aufbauen
  556. Init6510    lea    ReadTab0,a0        ;Alle mit RAM vorbelegen
  557.         move.w    #256*8-1,d0
  558. 1$        move.l    #ReadByteRAM,(a0)+
  559.         dbra    d0,1$
  560.  
  561.         lea    ReadTab3+160*4,a0    ;Basic-ROM
  562.         moveq    #31,d0
  563. 21$        move.l    #ReadByteBasic,(a0)+
  564.         dbra    d0,21$
  565.  
  566.         lea    ReadTab7+160*4,a0
  567.         moveq    #31,d0
  568. 22$        move.l    #ReadByteBasic,(a0)+
  569.         dbra    d0,22$
  570.  
  571.         lea    ReadTab2+224*4,a0    ;Kernal-ROM
  572.         moveq    #31,d0
  573. 31$        move.l    #ReadByteKernal,(a0)+
  574.         dbra    d0,31$
  575.  
  576.         lea    ReadTab3+224*4,a0
  577.         moveq    #31,d0
  578. 32$        move.l    #ReadByteKernal,(a0)+
  579.         dbra    d0,32$
  580.  
  581.         lea    ReadTab6+224*4,a0
  582.         moveq    #31,d0
  583. 33$        move.l    #ReadByteKernal,(a0)+
  584.         dbra    d0,33$
  585.  
  586.         lea    ReadTab7+224*4,a0
  587.         moveq    #31,d0
  588. 34$        move.l    #ReadByteKernal,(a0)+
  589.         dbra    d0,34$
  590.  
  591.         lea    ReadTab5+208*4,a0    ;I/O-Bereich
  592.         move.l    #ReadByteVIC,(a0)+
  593.         move.l    #ReadByteVIC,(a0)+
  594.         move.l    #ReadByteVIC,(a0)+
  595.         move.l    #ReadByteVIC,(a0)+
  596.         move.l    #ReadByteSID,(a0)+
  597.         move.l    #ReadByteSID,(a0)+
  598.         move.l    #ReadByteSID,(a0)+
  599.         move.l    #ReadByteSID,(a0)+
  600.         move.l    #ReadByteColor,(a0)+
  601.         move.l    #ReadByteColor,(a0)+
  602.         move.l    #ReadByteColor,(a0)+
  603.         move.l    #ReadByteColor,(a0)+
  604.         move.l    #ReadByteCIA1,(a0)+
  605.         move.l    #ReadByteCIA2,(a0)+
  606.         move.l    #ReadByteUndef,(a0)+
  607.         move.l    #ReadByteUndef,(a0)
  608.  
  609.         lea    ReadTab6+208*4,a0
  610.         move.l    #ReadByteVIC,(a0)+
  611.         move.l    #ReadByteVIC,(a0)+
  612.         move.l    #ReadByteVIC,(a0)+
  613.         move.l    #ReadByteVIC,(a0)+
  614.         move.l    #ReadByteSID,(a0)+
  615.         move.l    #ReadByteSID,(a0)+
  616.         move.l    #ReadByteSID,(a0)+
  617.         move.l    #ReadByteSID,(a0)+
  618.         move.l    #ReadByteColor,(a0)+
  619.         move.l    #ReadByteColor,(a0)+
  620.         move.l    #ReadByteColor,(a0)+
  621.         move.l    #ReadByteColor,(a0)+
  622.         move.l    #ReadByteCIA1,(a0)+
  623.         move.l    #ReadByteCIA2,(a0)+
  624.         move.l    #ReadByteUndef,(a0)+
  625.         move.l    #ReadByteUndef,(a0)
  626.  
  627.         lea    ReadTab7+208*4,a0
  628.         move.l    #ReadByteVIC,(a0)+
  629.         move.l    #ReadByteVIC,(a0)+
  630.         move.l    #ReadByteVIC,(a0)+
  631.         move.l    #ReadByteVIC,(a0)+
  632.         move.l    #ReadByteSID,(a0)+
  633.         move.l    #ReadByteSID,(a0)+
  634.         move.l    #ReadByteSID,(a0)+
  635.         move.l    #ReadByteSID,(a0)+
  636.         move.l    #ReadByteColor,(a0)+
  637.         move.l    #ReadByteColor,(a0)+
  638.         move.l    #ReadByteColor,(a0)+
  639.         move.l    #ReadByteColor,(a0)+
  640.         move.l    #ReadByteCIA1,(a0)+
  641.         move.l    #ReadByteCIA2,(a0)+
  642.         move.l    #ReadByteUndef,(a0)+
  643.         move.l    #ReadByteUndef,(a0)
  644.  
  645.         lea    ReadTab1+208*4,a0    ;Char-ROM
  646.         moveq    #15,d0
  647. 41$        move.l    #ReadByteChar,(a0)+
  648.         dbra    d0,41$
  649.  
  650.         lea    ReadTab2+208*4,a0
  651.         moveq    #15,d0
  652. 42$        move.l    #ReadByteChar,(a0)+
  653.         dbra    d0,42$
  654.  
  655.         lea    ReadTab3+208*4,a0
  656.         moveq    #15,d0
  657. 43$        move.l    #ReadByteChar,(a0)+
  658.         dbra    d0,43$
  659.  
  660. ; WriteTabs aufbauen
  661.         lea    WriteTab0,a0        ;Alle mit RAM vorbelegen
  662.         move.w    #256*8-1,d0
  663. 5$        move.l    #WriteByteRAM,(a0)+
  664.         dbra    d0,5$
  665.  
  666.         move.l    #WriteBytePage0,WriteTab0 ;Zeropage immer speziell
  667.         move.l    #WriteBytePage0,WriteTab1
  668.         move.l    #WriteBytePage0,WriteTab2
  669.         move.l    #WriteBytePage0,WriteTab3
  670.         move.l    #WriteBytePage0,WriteTab4
  671.         move.l    #WriteBytePage0,WriteTab5
  672.         move.l    #WriteBytePage0,WriteTab6
  673.         move.l    #WriteBytePage0,WriteTab7
  674.  
  675.         lea    WriteTab5+208*4,a0    ;I/O-Bereich
  676.         move.l    #WriteByteVIC,(a0)+
  677.         move.l    #WriteByteVIC,(a0)+
  678.         move.l    #WriteByteVIC,(a0)+
  679.         move.l    #WriteByteVIC,(a0)+
  680.         move.l    #WriteByteSID,(a0)+
  681.         move.l    #WriteByteSID,(a0)+
  682.         move.l    #WriteByteSID,(a0)+
  683.         move.l    #WriteByteSID,(a0)+
  684.         move.l    #WriteByteColor,(a0)+
  685.         move.l    #WriteByteColor,(a0)+
  686.         move.l    #WriteByteColor,(a0)+
  687.         move.l    #WriteByteColor,(a0)+
  688.         move.l    #WriteByteCIA1,(a0)+
  689.         move.l    #WriteByteCIA2,(a0)+
  690.         move.l    #WriteByteUndef,(a0)+
  691.         move.l    #WriteByteUndef,(a0)
  692.  
  693.         lea    WriteTab6+208*4,a0
  694.         move.l    #WriteByteVIC,(a0)+
  695.         move.l    #WriteByteVIC,(a0)+
  696.         move.l    #WriteByteVIC,(a0)+
  697.         move.l    #WriteByteVIC,(a0)+
  698.         move.l    #WriteByteSID,(a0)+
  699.         move.l    #WriteByteSID,(a0)+
  700.         move.l    #WriteByteSID,(a0)+
  701.         move.l    #WriteByteSID,(a0)+
  702.         move.l    #WriteByteColor,(a0)+
  703.         move.l    #WriteByteColor,(a0)+
  704.         move.l    #WriteByteColor,(a0)+
  705.         move.l    #WriteByteColor,(a0)+
  706.         move.l    #WriteByteCIA1,(a0)+
  707.         move.l    #WriteByteCIA2,(a0)+
  708.         move.l    #WriteByteUndef,(a0)+
  709.         move.l    #WriteByteUndef,(a0)
  710.  
  711.         lea    WriteTab7+208*4,a0
  712.         move.l    #WriteByteVIC,(a0)+
  713.         move.l    #WriteByteVIC,(a0)+
  714.         move.l    #WriteByteVIC,(a0)+
  715.         move.l    #WriteByteVIC,(a0)+
  716.         move.l    #WriteByteSID,(a0)+
  717.         move.l    #WriteByteSID,(a0)+
  718.         move.l    #WriteByteSID,(a0)+
  719.         move.l    #WriteByteSID,(a0)+
  720.         move.l    #WriteByteColor,(a0)+
  721.         move.l    #WriteByteColor,(a0)+
  722.         move.l    #WriteByteColor,(a0)+
  723.         move.l    #WriteByteColor,(a0)+
  724.         move.l    #WriteByteCIA1,(a0)+
  725.         move.l    #WriteByteCIA2,(a0)+
  726.         move.l    #WriteByteUndef,(a0)+
  727.         move.l    #WriteByteUndef,(a0)
  728.  
  729. ; JumpTabs aufbauen
  730.         lea    JumpTab0,a0        ;Alle mit RAM vorbelegen
  731.         move.w    #256*8-1,d0
  732. 6$        move.l    #JumpToRAM,(a0)+
  733.         dbra    d0,6$
  734.  
  735.         lea    JumpTab3+160*4,a0    ;Basic-ROM
  736.         moveq    #31,d0
  737. 71$        move.l    #JumpToBasic,(a0)+
  738.         dbra    d0,71$
  739.  
  740.         lea    JumpTab7+160*4,a0
  741.         moveq    #31,d0
  742. 72$        move.l    #JumpToBasic,(a0)+
  743.         dbra    d0,72$
  744.  
  745.         lea    JumpTab2+224*4,a0    ;Kernal-ROM
  746.         moveq    #31,d0
  747. 81$        move.l    #JumpToKernal,(a0)+
  748.         dbra    d0,81$
  749.  
  750.         lea    JumpTab3+224*4,a0
  751.         moveq    #31,d0
  752. 82$        move.l    #JumpToKernal,(a0)+
  753.         dbra    d0,82$
  754.  
  755.         lea    JumpTab6+224*4,a0
  756.         moveq    #31,d0
  757. 83$        move.l    #JumpToKernal,(a0)+
  758.         dbra    d0,83$
  759.  
  760.         lea    JumpTab7+224*4,a0
  761.         moveq    #31,d0
  762. 84$        move.l    #JumpToKernal,(a0)+
  763.         dbra    d0,84$
  764.  
  765.         lea    JumpTab1+208*4,a0    ;Char-ROM
  766.         moveq    #15,d0
  767. 85$        move.l    #JumpToChar,(a0)+
  768.         dbra    d0,85$
  769.  
  770.         lea    JumpTab2+208*4,a0
  771.         moveq    #15,d0
  772. 86$        move.l    #JumpToChar,(a0)+
  773.         dbra    d0,86$
  774.  
  775.         lea    JumpTab3+208*4,a0
  776.         moveq    #15,d0
  777. 87$        move.l    #JumpToChar,(a0)+
  778.         dbra    d0,87$
  779.  
  780.         lea    JumpTab5+208*4,a0    ;I/O-Bereich
  781.         moveq    #15,d0
  782. 88$        move.l    #JumpToIO,(a0)+
  783.         dbra    d0,88$
  784.  
  785.         lea    JumpTab6+208*4,a0
  786.         moveq    #15,d0
  787. 89$        move.l    #JumpToIO,(a0)+
  788.         dbra    d0,89$
  789.  
  790.         lea    JumpTab7+208*4,a0
  791.         moveq    #15,d0
  792. 810$        move.l    #JumpToIO,(a0)+
  793.         dbra    d0,810$
  794.         rts
  795.  
  796.  
  797. **
  798. ** 6510-Task starten
  799. ** Rückgabe: d0#0 = Fehler
  800. **
  801.  
  802. ; Signal einrichten
  803. Start6510    move.l    _SysBase,a6
  804.         moveq    #-1,d0
  805.         JSRLIB    AllocSignal
  806.         move.b    d0,ReadySig
  807.         moveq    #0,d1
  808.         bset    d0,d1
  809.         move.l    d1,ReadySet
  810.  
  811. ; Task starten
  812.         move.l    _DOSBase,a6
  813.         move.l    #ProcTags,d1
  814.         JSRLIB    CreateNewProc
  815.         move.l    d0,CPUProc
  816.         beq    1$
  817.  
  818. ; Auf Signal warten
  819.         move.l    _SysBase,a6
  820.         move.l    ReadySet,d0
  821.         JSRLIB    Wait
  822.         moveq    #0,d0        ;Alles OK
  823.         rts
  824.  
  825. ; Fehler aufgetreten
  826. 1$        moveq    #-1,d0
  827.         rts
  828.  
  829.  
  830. **
  831. ** 6510-Task stoppen
  832. **
  833.  
  834. ; Task stoppen
  835. Stop6510    move.l    _SysBase,a6
  836.         tst.l    CPUProc(pc)
  837.         beq    1$
  838.         st.b    RESETIsEXIT    ;EXIT-Reset auslösen
  839.         st.b    IntIsRESET
  840.         move.l    ReadySet,d0
  841.         JSRLIB    Wait
  842.  
  843. ; Signal freigeben
  844. 1$        move.b    ReadySig,d0
  845.         JMPLIB    FreeSignal
  846.  
  847.  
  848. **
  849. ** 6510-Task anhalten
  850. **
  851.  
  852. Pause6510    move.l    _SysBase,a6
  853.         st.b    RESETIsPause    ;Pause-Reset auslösen
  854.         st.b    IntIsRESET
  855.         move.l    ReadySet,d0
  856.         JMPLIB    Wait
  857.  
  858.  
  859. **
  860. ** 6510-Task fortsetzen
  861. **
  862.  
  863. Resume6510    move.l    _SysBase,a6
  864.         move.l    CPUTask,a1    ;Continue-Signal schicken
  865.         move.l    ContinueSet,d0
  866.         JMPLIB    Signal
  867.  
  868.  
  869. **
  870. ** Strings in Datenstrukturen lokalisieren
  871. **
  872.  
  873. GetStr        MACRO    ;Label
  874.         lea    TheLocale,a0
  875.         move.l    #\1,d0
  876.         jsr    GetString
  877.         ENDM
  878.  
  879. Localize6510    GetStr    MSG_REQTITLE
  880.         move.l    d0,IllegalOpReq+8
  881.         move.l    d0,JumpToIOReq+8
  882.  
  883.         GetStr    MSG_REQGADS3
  884.         move.l    d0,IllegalOpReq+16
  885.  
  886.         GetStr    MSG_REQGADS4
  887.         move.l    d0,JumpToIOReq+16
  888.  
  889.         GetStr    MSG_ILLEGALOP
  890.         move.l    d0,IllegalOpReq+12
  891.  
  892.         GetStr    MSG_JUMPTOIO
  893.         move.l    d0,JumpToIOReq+12
  894.         rts
  895.  
  896.  
  897. **
  898. ** 6510-Emulator
  899. **
  900. ** Register:
  901. **  d0: Scratch (Oberes Wort muß IMMER Null sein!)
  902. **  d1: Scratch (Oberes Wort muß IMMER Null sein!)
  903. **
  904.  
  905. ; Task ermitteln
  906. CPUTaskProc    move.l    _SysBase,a6
  907.         sub.l    a1,a1
  908.         JSRLIB    FindTask
  909.         move.l    d0,CPUTask
  910.  
  911. ; Continue-Signal holen
  912.         moveq    #-1,d0
  913.         JSRLIB    AllocSignal
  914.         move.b    d0,ContinueSig
  915.         moveq    #0,d1
  916.         bset    d0,d1
  917.         move.l    d1,ContinueSet
  918.  
  919. ; 6569 initialisieren
  920.         bsr    Init6569
  921.  
  922. ; Signal an den Emulator schicken
  923.         move.l    _SysBase,a6
  924.         move.l    MainTask,a1
  925.         move.l    ReadySet,d0
  926.         JSRLIB    Signal
  927.  
  928. ; Variablen initilisieren
  929.         clr.l    Interrupt
  930.         clr.b    RESETIsEXIT
  931.         clr.b    RESETIsPause
  932.         move.w    #63,CyclesLeft
  933.  
  934. ; Speicherkonfiguration initialisieren
  935.         move.l    TheRAM,RAMPTR
  936.         move.w    #$ff07,(RAMPTR)
  937.         NewConfig
  938.  
  939. ; Register setzen
  940.         moveq    #0,d0
  941.         moveq    #0,d1
  942.         moveq    #0,RA
  943.         moveq    #0,RX
  944.         moveq    #0,RY
  945.         move.l    #$01ff,RS
  946.         moveq    #0,RCCR
  947.         move.l    #InterruptMask,RP
  948.         lea    OpcodeTable,OPTABPTR
  949.  
  950. ; Reset-Vektor lesen, PC setzen und ersten Befehl ausführen
  951.         move.w    #$fffc,d0
  952.         ReadWord
  953.         Jump
  954.         Next    0
  955.  
  956. ; Unbekannten Opcode entdeckt: Requester darstellen
  957. IllegalOp    movem.l    a2-a6,-(sp)
  958.  
  959.         and.w    #$00ff,d0        ;Opcode
  960.         move.w    d0,RequestStream
  961.         move.l    RPC,d0            ;und PC anzeigen
  962.         subq.w    #1,d0
  963.         move.w    d0,RequestStream+2
  964.  
  965.         bsr    AmigaToFront
  966.  
  967.         move.l    _IntuitionBase,a6
  968.         sub.l    a0,a0
  969.         lea    IllegalOpReq,a1
  970.         move.l    a0,a2
  971.         lea    RequestStream,a3
  972.         JSRLIB    EasyRequestArgs
  973.  
  974.         move.l    d0,-(sp)
  975.         bsr    EmulToFront
  976.         move.l    (sp)+,d0
  977.  
  978.         movem.l    (sp)+,a2-a6
  979.  
  980.         tst.l    d0
  981.         beq    1$
  982.  
  983.         bsr    Reset6526    ;Reset
  984.         bsr    Reset6581
  985.         moveq    #0,d0        ;MSWs von d0 und d1
  986.         moveq    #0,d1        ; müssen Null sein
  987.         bra    HandleRESET
  988.  
  989. 1$        moveq    #0,d0        ;Weiter
  990.         moveq    #0,d1
  991.         Next    0
  992.  
  993.  
  994. **
  995. ** Speicherzugriff Lesen
  996. ** In a1 steht die Rücksprungadresse
  997. **
  998.  
  999. ; Lesen aus dem RAM
  1000. ReadByteRAM    move.b    (RAMPTR,d0.l),d0
  1001.         jmp    (a1)
  1002.  
  1003. ; Lesen aus dem Basic-ROM
  1004. ReadByteBasic    and.w    #$1fff,d0
  1005.         move.b    ([TheBasic,pc],d0.w),d0
  1006.         jmp    (a1)
  1007.  
  1008. ; Lesen aus einem VIC-Register
  1009. ReadByteVIC    and.w    #$3f,d0
  1010.         bsr    ReadFrom6569
  1011.         jmp    (a1)
  1012.  
  1013. ; Lesen aus einem SID-Register
  1014. ReadByteSID    and.w    #$1f,d0
  1015.         bsr    ReadFrom6581
  1016.         jmp    (a1)
  1017.  
  1018. ; Lesen aus dem Farb-RAM
  1019. ReadByteColor    and.w    #$03ff,d0
  1020.         move.b    ([TheColor,pc],d0.w),d1
  1021.         and.b    #$0f,d1
  1022.  
  1023.         move.l    d1,-(sp)
  1024.         bsr    Random        ;Oberes Nibble ist Zufallswert
  1025.         and.b    #$f0,d0
  1026.         move.l    (sp)+,d1
  1027.  
  1028.         or.b    d1,d0
  1029.         jmp    (a1)
  1030.  
  1031. ; Lesen aus einem CIA 1-Register
  1032. ReadByteCIA1    and.w    #$0f,d0
  1033.         bsr    ReadFrom6526A
  1034.         jmp    (a1)
  1035.  
  1036. ; Lesen aus einem CIA 2-Register
  1037. ReadByteCIA2    and.w    #$0f,d0
  1038.         bsr    ReadFrom6526B
  1039.         jmp    (a1)
  1040.  
  1041. ; Lesen einer offenen Adresse
  1042. ReadByteUndef    cmp.l    #$dfa0,d0
  1043.         bhs    1$
  1044.         bsr    Random        ;Zufallswert
  1045.         moveq    #0,d1        ;MSW löschen
  1046.         jmp    (a1)
  1047.  
  1048. ; $dfa0-$dfff: Emulator-Identifikation
  1049. 1$        cmp.w    #$dfff,d0    ;$dfff liest abwechselnd $55/$aa
  1050.         bne    2$
  1051.         move.b    DFFFByte,d0
  1052.         not.b    DFFFByte
  1053.         jmp    (a1)        
  1054.  
  1055. 2$        cmp.w    #$dffe,d0    ;$dffe liest "F" (Frodo-Kennung)
  1056.         bne    3$
  1057.         moveq    #'F',d0
  1058.         jmp    (a1)
  1059.  
  1060. 3$        cmp.w    #$dffd,d0    ;$dffd: Version
  1061.         bne    4$
  1062.         move.b    #VERSION,d0
  1063.         jmp    (a1)
  1064.  
  1065. 4$        cmp.w    #$dffc,d0    ;$dffc: Revision
  1066.         bne    5$
  1067.         move.b    #REVISION,d0
  1068.         jmp    (a1)
  1069.  
  1070. 5$        sub.w    #$dfa0,d0    ;$dfa0-$dffb: ID-String
  1071.         move.b    IDString(pc,d0.w),d0
  1072.         jmp    (a1)
  1073.  
  1074. ; Lesen aus dem Kernal-ROM
  1075. ReadByteKernal    and.w    #$1fff,d0
  1076.         move.b    ([TheKernal,pc],d0.w),d0
  1077.         jmp    (a1)
  1078.  
  1079. ; Lesen aus dem Char-ROM
  1080. ReadByteChar    and.w    #$0fff,d0
  1081.         move.b    ([TheChar,pc],d0.w),d0
  1082.         jmp    (a1)
  1083.  
  1084.  
  1085. **
  1086. ** Speicherzugriff Schreiben
  1087. ** In a1 steht die 16-Bit-Adresse
  1088. **
  1089.  
  1090. ; Schreiben in Seite 0
  1091. WriteBytePage0    move.l    a1,d0
  1092.         move.b    d1,(RAMPTR,d0.w)
  1093.         cmp.b    #2,d0
  1094.         bhs    1$
  1095.         NewConfig
  1096. 1$        rts
  1097.  
  1098. ; Schreiben ins RAM
  1099. WriteByteRAM    move.b    d1,(RAMPTR,a1.l)
  1100.         rts
  1101.  
  1102. ; Schreiben in ein VIC-Register
  1103. WriteByteVIC    move.l    a1,d0
  1104.         and.w    #$3f,d0
  1105.         bra    WriteTo6569
  1106.  
  1107. ; Schreiben in ein SID-Register
  1108. WriteByteSID    move.l    a1,d0
  1109.         and.w    #$1f,d0
  1110.         bra    WriteTo6581
  1111.  
  1112. ; Schreiben ins Farb-RAM
  1113. WriteByteColor    move.l    a1,d0
  1114.         and.w    #$03ff,d0
  1115.         move.b    d1,([TheColor],d0.w)
  1116.         rts
  1117.  
  1118. ; Schreiben in ein CIA 1-Register
  1119. WriteByteCIA1    move.l    a1,d0
  1120.         and.w    #$0f,d0
  1121.         bra    WriteTo6526A
  1122.  
  1123. ; Schreiben in ein CIA 2-Register
  1124. WriteByteCIA2    move.l    a1,d0
  1125.         and.w    #$0f,d0
  1126.         bra    WriteTo6526B
  1127.  
  1128. ; Schreiben an einer offenen Adresse
  1129. WriteByteUndef    move.l    a1,d0
  1130.         rts
  1131.  
  1132.  
  1133. **
  1134. ** Sprungbefehle
  1135. **
  1136.  
  1137. ; Sprung ins RAM
  1138. JumpToRAM    lea    (RAMPTR,d0.l),RPC
  1139.         rts
  1140.  
  1141. ; Sprung ins Basic-ROM
  1142. JumpToBasic    move.l    TheBasic(pc),RPC
  1143.         and.w    #$1fff,d0
  1144.         add.l    d0,RPC
  1145.         rts
  1146.  
  1147. ; Sprung ins Kernal-ROM
  1148. JumpToKernal    move.l    TheKernal(pc),RPC
  1149.         and.w    #$1fff,d0
  1150.         add.l    d0,RPC
  1151.         rts
  1152.  
  1153. ; Sprung ins Char-ROM (warum sollte jemand sowas tun? Aber egal.)
  1154. JumpToChar    move.l    TheChar(pc),RPC
  1155.         and.w    #$0fff,d0
  1156.         add.l    d0,RPC
  1157.         rts
  1158.  
  1159. ; Sprung in den I/O-Bereich (in VIC-Register wird ab und zu gerne gesprungen,
  1160. ;  $de00 und das Farb-RAM sind auch sehr beliebt :-)
  1161. JumpToIO    movem.l    a2-a6,-(sp)
  1162.  
  1163.         move.w    d0,RequestStream    ;PC anzeigen
  1164.  
  1165.         bsr    AmigaToFront
  1166.  
  1167.         move.l    _IntuitionBase,a6
  1168.         sub.l    a0,a0
  1169.         lea    JumpToIOReq,a1
  1170.         move.l    a0,a2
  1171.         lea    RequestStream,a3
  1172.         JSRLIB    EasyRequestArgs
  1173.  
  1174.         bsr    EmulToFront
  1175.  
  1176.         movem.l    (sp)+,a2-a6
  1177.  
  1178.         bsr    Reset6526
  1179.         bsr    Reset6581
  1180.         moveq    #0,d0            ;MSWs von d0 und d1
  1181.         moveq    #0,d1            ; müssen Null sein
  1182.  
  1183.         addq.l    #4,sp            ;Rücksprungadresse löschen
  1184.         bra    HandleRESET
  1185.  
  1186.  
  1187. **
  1188. ** Opcode-Routinen
  1189. **
  1190.  
  1191. *
  1192. * Interrupts handhaben
  1193. *
  1194.  
  1195. ; Art des Interrupt feststellen (Priorität)
  1196. HandleInt    tst.b    IntIsRESET(pc)
  1197.         bne    HandleRESET
  1198.         tst.b    IntIsNMI(pc)
  1199.         bne    HandleNMI
  1200.         tst.b    IntIsVICIRQ(pc)
  1201.         bne    HandleVICIRQ
  1202.         tst.b    IntIsCIAIRQ(pc)
  1203.         bne    HandleCIAIRQ
  1204.  
  1205. ; Kein Interrupt, nächsten Befehl ausführen
  1206. HandleIntDone    Next    0
  1207.  
  1208. ; IRQ: Interrupt-Bit testen, nach ($fffe) springen
  1209. HandleVICIRQ    btst    #InterruptBit,RP
  1210.         beq    HandleIRQ
  1211.         Next    0
  1212.  
  1213. HandleCIAIRQ    btst    #InterruptBit,RP
  1214.         beq    HandleIRQ
  1215.         Next    0
  1216.  
  1217. HandleIRQ    PushPC
  1218.         PushP
  1219.  
  1220.         or.w    #InterruptMask,RP
  1221.         move.w    #$fffe,d0    ;IRQ-Vektor
  1222.         ReadWord
  1223.         Jump
  1224.         Next    7
  1225.  
  1226. ; NMI: Nach ($fffa) springen
  1227. HandleNMI    clr.b    IntIsNMI    ;Simuliert einen flankengetriggerten Eingang
  1228.  
  1229.         PushPC
  1230.         PushP
  1231.  
  1232.         or.w    #InterruptMask,RP
  1233.         move.w    #$fffa,d0    ;NMI-Vektor
  1234.         ReadWord
  1235.         Jump
  1236.         Next    7
  1237.  
  1238. ; RESET: Emulator beenden oder nach ($fffc) springen
  1239. HandleRESET    tst.b    RESETIsEXIT    ;Beenden?
  1240.         bne    HandleEXIT
  1241.         tst.b    RESETIsPause    ;Pause?
  1242.         bne    HandlePause
  1243.  
  1244.         clr.l    Interrupt    ;Nein, RESET
  1245.  
  1246.         cmp.l    #$c3c2cd38,$8004(RAMPTR)
  1247.         bne    1$
  1248.         cmp.b    #$30,$8008(RAMPTR)
  1249.         bne    1$
  1250.         clr.b    $8004(RAMPTR)    ;CBM80 löschen, wenn vorhanden
  1251.  
  1252. 1$        move.w    #$ff07,(RAMPTR)    ;Speicherkonfiguration initialisieren
  1253.         NewConfig
  1254.  
  1255.         move.w    #$fffc,d0    ;RESET-Vektor
  1256.         ReadWord
  1257.         Jump
  1258.         Next    0
  1259.  
  1260. ; EXIT: Signal an den Emulator schicken
  1261. HandleEXIT    bsr    Exit6569        ;6569 aufräumen
  1262.  
  1263.         move.l    _SysBase,a6
  1264.  
  1265.         moveq    #0,d0
  1266.         move.b    ContinueSig,d0
  1267.         JSRLIB    FreeSignal
  1268.  
  1269.         JSRLIB    Forbid
  1270.         move.l    MainTask,a1
  1271.         move.l    ReadySet,d0
  1272.         JSRLIB    Signal
  1273.         moveq    #0,d0
  1274.         rts
  1275.  
  1276. ; Pause: Signal an den Emulator schicken und dann selbst auf
  1277. ;  ein Signal warten
  1278. HandlePause    clr.l    Interrupt
  1279.         clr.b    RESETIsPause
  1280.  
  1281.         movem.l    d2-d7/a2-a6,-(sp)
  1282.  
  1283.         move.l    _SysBase,a6
  1284.         move.l    MainTask,a1
  1285.         move.l    ReadySet,d0
  1286.         JSRLIB    Signal
  1287.  
  1288.         move.l    ContinueSet,d0
  1289.         JSRLIB    Wait
  1290.  
  1291.         movem.l    (sp)+,d2-d7/a2-a6
  1292.         moveq    #0,d0
  1293.         moveq    #0,d1
  1294.  
  1295.         Next    0
  1296.  
  1297.  
  1298. *
  1299. * Opcodes
  1300. *
  1301.  
  1302. ; Laden
  1303. LoadA        MACRO    ;Quelle, Zyklenzahl
  1304.         move.b    \1,RA
  1305.         move    ccr,RCCR
  1306.         Next    \2
  1307.         ENDM
  1308.  
  1309. LoadX        MACRO    ;Quelle, Zyklenzahl
  1310.         move.b    \1,RX
  1311.         move    ccr,RCCR
  1312.         Next    \2
  1313.         ENDM
  1314.  
  1315. LoadY        MACRO    ;Quelle, Zyklenzahl
  1316.         move.b    \1,RY
  1317.         move    ccr,RCCR
  1318.         Next    \2
  1319.         ENDM
  1320.  
  1321. LoadAX        MACRO    ;Quelle, Zyklenzahl
  1322.         move.b    \1,RA
  1323.         move.b    RA,RX
  1324.         move    ccr,RCCR
  1325.         Next    \2
  1326.         ENDM
  1327.  
  1328. LDAImm        LoadA    (RPC)+,2
  1329.  
  1330. LDAZero        ReadAdrZero
  1331.         LoadA    (RAMPTR,d0.w),3
  1332.  
  1333. LDAZeroX    ReadAdrZeroX
  1334.         LoadA    (RAMPTR,d0.w),4
  1335.  
  1336. LDAAbs        ReadByteAbs
  1337.         LoadA    d0,4
  1338.  
  1339. LDAAbsX        ReadByteAbsX
  1340.         LoadA    d0,4
  1341.  
  1342. LDAAbsY        ReadByteAbsY
  1343.         LoadA    d0,4
  1344.  
  1345. LDAIndX        ReadByteIndX
  1346.         LoadA    d0,6
  1347.  
  1348. LDAIndY        ReadByteIndY
  1349.         LoadA    d0,5
  1350.  
  1351. LDXImm        LoadX    (RPC)+,2
  1352.  
  1353. LDXZero        ReadAdrZero
  1354.         LoadX    (RAMPTR,d0.w),3
  1355.  
  1356. LDXZeroY    ReadAdrZeroY
  1357.         LoadX    (RAMPTR,d0.w),4
  1358.  
  1359. LDXAbs        ReadByteAbs
  1360.         LoadX    d0,4
  1361.  
  1362. LDXAbsY        ReadByteAbsY
  1363.         LoadX    d0,4
  1364.  
  1365. LDYImm        LoadY    (RPC)+,2
  1366.  
  1367. LDYZero        ReadAdrZero
  1368.         LoadY    (RAMPTR,d0.w),3
  1369.  
  1370. LDYZeroX    ReadAdrZeroX
  1371.         LoadY    (RAMPTR,d0.w),4
  1372.  
  1373. LDYAbs        ReadByteAbs
  1374.         LoadY    d0,4
  1375.  
  1376. LDYAbsX        ReadByteAbsX
  1377.         LoadY    d0,4
  1378.  
  1379. LAXZero        ReadAdrZero
  1380.         LoadAX    (RAMPTR,d0.w),3
  1381.  
  1382. LAXZeroY    ReadAdrZeroY
  1383.         LoadAX    (RAMPTR,d0.w),4
  1384.  
  1385. LAXAbs        ReadByteAbs
  1386.         LoadAX    d0,4
  1387.  
  1388. LAXAbsY        ReadByteAbsY
  1389.         LoadAX    d0,4
  1390.  
  1391. LAXIndX        ReadByteIndX
  1392.         LoadAX    d0,6
  1393.  
  1394. LAXIndY        ReadByteIndY
  1395.         LoadAX    d0,5
  1396.  
  1397. ; Speichern
  1398. StoreA        MACRO    ;Zyklenzahl
  1399.         move.b    RA,d1
  1400.         WriteByte
  1401.         Next    \1
  1402.         ENDM
  1403.  
  1404. StoreAX        MACRO    ;Zyklenzahl
  1405.         move.b    RA,d1
  1406.         and.b    RX,d1
  1407.         WriteByte
  1408.         Next    \1
  1409.         ENDM
  1410.  
  1411. STAZero        ReadAdrZero
  1412.         WriteZeroNext    RA,3
  1413.  
  1414. STAZeroX    ReadAdrZeroX
  1415.         WriteZeroNext    RA,4
  1416.  
  1417. STAAbs        ReadAdrAbs
  1418.         StoreA    4
  1419.  
  1420. STAAbsX        ReadAdrAbsX
  1421.         StoreA    5
  1422.  
  1423. STAAbsY        ReadAdrAbsY
  1424.         StoreA    5
  1425.  
  1426. STAIndX        ReadAdrIndX
  1427.         StoreA    6
  1428.  
  1429. STAIndY        ReadAdrIndY
  1430.         StoreA    6
  1431.  
  1432. STXZero        ReadAdrZero
  1433.         WriteZeroNext    RX,3
  1434.  
  1435. STXZeroY    ReadAdrZeroY
  1436.         WriteZeroNext    RX,4
  1437.  
  1438. STXAbs        ReadAdrAbs
  1439.         move.b    RX,d1
  1440.         WriteByte
  1441.         Next    4
  1442.  
  1443. STYZero        ReadAdrZero
  1444.         WriteZeroNext    RY,3
  1445.  
  1446. STYZeroX    ReadAdrZeroX
  1447.         WriteZeroNext    RY,4
  1448.  
  1449. STYAbs        ReadAdrAbs
  1450.         move.b    RY,d1
  1451.         WriteByte
  1452.         Next    4
  1453.  
  1454. SAXZero        ReadAdrZero
  1455.         StoreAX    3
  1456.  
  1457. SAXZeroY    ReadAdrZeroY
  1458.         StoreAX    4
  1459.  
  1460. SAXAbs        ReadAdrAbs
  1461.         StoreAX    4
  1462.  
  1463. SAXIndX        ReadAdrIndX
  1464.         StoreAX    6
  1465.  
  1466. ; Datentransport zwischen Registern
  1467. TAX        move.b    RA,RX
  1468.         move    ccr,RCCR
  1469.         Next    2
  1470.  
  1471. TAY        move.b    RA,RY
  1472.         move    ccr,RCCR
  1473.         Next    2
  1474.  
  1475. TXA        move.b    RX,RA
  1476.         move    ccr,RCCR
  1477.         Next    2
  1478.  
  1479. TYA        move.b    RY,RA
  1480.         move    ccr,RCCR
  1481.         Next    2
  1482.  
  1483. TXS        move.b    RX,RS
  1484.         Next    2
  1485.  
  1486. TSX        move.b    RS,RX
  1487.         move    ccr,RCCR
  1488.         Next    2
  1489.  
  1490. ; Stack
  1491. PHA        PushByte RA
  1492.         Next    3
  1493.  
  1494. PLA        PopByte    RA
  1495.         move    ccr,RCCR
  1496.         Next    4
  1497.  
  1498. PHP        or.w    #BreakMask,RP    ;Prozessorfehler: Break-Flag
  1499.         PushP            ; wird auf dem Stack gesetzt
  1500.         and.w    #~BreakMask,RP
  1501.         Next    3
  1502.  
  1503. PLP        PopP
  1504.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  1505.         beq    1$
  1506.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  1507.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  1508. 1$        Next    4
  1509.  
  1510. ; Vergleiche
  1511. CompareA    MACRO    ;Quelle, Zyklenzahl
  1512.         cmp.b    \1,RA
  1513.         move    ccr,RCCR
  1514.         move.b    RCCR,RP        ;Carry holen und invertieren
  1515.         not.b    RP
  1516.         Next    \2
  1517.         ENDM
  1518.  
  1519. CMPImm        CompareA    (RPC)+,2
  1520.  
  1521. CMPZero        ReadAdrZero
  1522.         CompareA    (RAMPTR,d0.w),3
  1523.  
  1524. CMPZeroX    ReadAdrZeroX
  1525.         CompareA    (RAMPTR,d0.w),4
  1526.  
  1527. CMPAbs        ReadByteAbs
  1528.         CompareA    d0,4
  1529.  
  1530. CMPAbsX        ReadByteAbsX
  1531.         CompareA    d0,4
  1532.  
  1533. CMPAbsY        ReadByteAbsY
  1534.         CompareA    d0,4
  1535.  
  1536. CMPIndX        ReadByteIndX
  1537.         CompareA    d0,6
  1538.  
  1539. CMPIndY        ReadByteIndY
  1540.         CompareA    d0,5
  1541.  
  1542. CPXImm        cmp.b    (RPC)+,RX
  1543.         move    ccr,RCCR
  1544.         move.b    RCCR,RP        ;Carry holen und invertieren
  1545.         not.b    RP
  1546.         Next    2
  1547.  
  1548. CPXZero        ReadAdrZero
  1549.         cmp.b    (RAMPTR,d0.w),RX
  1550.         move    ccr,RCCR
  1551.         move.b    RCCR,RP        ;Carry holen und invertieren
  1552.         not.b    RP
  1553.         Next    3
  1554.  
  1555. CPXAbs        ReadByteAbs
  1556.         cmp.b    d0,RX
  1557.         move    ccr,RCCR
  1558.         move.b    RCCR,RP        ;Carry holen und invertieren
  1559.         not.b    RP
  1560.         Next    4
  1561.  
  1562. CPYImm        cmp.b    (RPC)+,RY
  1563.         move    ccr,RCCR
  1564.         move.b    RCCR,RP        ;Carry holen und invertieren
  1565.         not.b    RP
  1566.         Next    2
  1567.  
  1568. CPYZero        ReadAdrZero
  1569.         cmp.b    (RAMPTR,d0.w),RY
  1570.         move    ccr,RCCR
  1571.         move.b    RCCR,RP        ;Carry holen und invertieren
  1572.         not.b    RP
  1573.         Next    3
  1574.  
  1575. CPYAbs        ReadByteAbs
  1576.         cmp.b    d0,RY
  1577.         move    ccr,RCCR
  1578.         move.b    RCCR,RP        ;Carry holen und invertieren
  1579.         not.b    RP
  1580.         Next    4
  1581.  
  1582. ; Arithmetische Operationen
  1583. AdcA        MACRO    ;Zyklenzahl
  1584.         lsr.b    #1,RP        ;Carry -> X
  1585.         btst    #DecimalBit,RP
  1586.         bne    \@1$
  1587.         addx.b    d0,RA
  1588.         move    ccr,RCCR
  1589.         bvc    \@2$        ;Overflow holen
  1590.         or.w    #OverflowMask,RP
  1591.         move.b    RCCR,RP        ;Carry holen
  1592.         Next    \1
  1593. \@2$        and.w    #~OverflowMask,RP
  1594.         move.b    RCCR,RP        ;Carry holen
  1595.         Next    \1
  1596. \@1$        moveq    #0,d1        ;V und C löschen
  1597.         abcd.b    d0,RA
  1598.         move    ccr,RCCR
  1599.         bvc    \@2$        ;Overflow holen
  1600.         or.w    #OverflowMask,RP
  1601.         move.b    RCCR,RP        ;Carry holen
  1602.         Next    \1
  1603.         ENDM
  1604.  
  1605. ADCImm        move.b    (RPC)+,d0
  1606.         AdcA    2
  1607.  
  1608. ADCZero        ReadByteZero    d0
  1609.         AdcA    3
  1610.  
  1611. ADCZeroX    ReadByteZeroX    d0
  1612.         AdcA    4
  1613.  
  1614. ADCAbs        ReadByteAbs
  1615.         AdcA    4
  1616.  
  1617. ADCAbsX        ReadByteAbsX
  1618.         AdcA    4
  1619.  
  1620. ADCAbsY        ReadByteAbsY
  1621.         AdcA    4
  1622.  
  1623. ADCIndX        ReadByteIndX
  1624.         AdcA    6
  1625.  
  1626. ADCIndY        ReadByteIndY
  1627.         AdcA    5
  1628.  
  1629. SbcA        MACRO    ;Zyklenzahl
  1630.         not.b    RP
  1631.         lsr.b    #1,RP        ;Carry invertieren und nach X
  1632.         btst    #DecimalBit,RP
  1633.         bne    \@1$
  1634.         subx.b    d0,RA
  1635.         move    ccr,RCCR
  1636.         bvc    \@2$        ;Overflow holen
  1637.         or.w    #OverflowMask,RP
  1638.         move.b    RCCR,RP        ;Carry holen und invertieren
  1639.         not.b    RP
  1640.         Next    \1
  1641. \@2$        and.w    #~OverflowMask,RP
  1642.         move.b    RCCR,RP        ;Carry holen und invertieren
  1643.         not.b    RP
  1644.         Next    \1
  1645. \@1$        moveq    #0,d1        ;V und C löschen
  1646.         sbcd.b    d0,RA
  1647.         move    ccr,RCCR
  1648.         bvc    \@2$        ;Overflow holen
  1649.         or.w    #OverflowMask,RP
  1650.         move.b    RCCR,RP        ;Carry holen und invertieren
  1651.         not.b    RP
  1652.         Next    \1
  1653.         ENDM
  1654.  
  1655. SBCImm        move.b    (RPC)+,d0
  1656.         SbcA    2
  1657.  
  1658. SBCZero        ReadByteZero    d0
  1659.         SbcA    3
  1660.  
  1661. SBCZeroX    ReadByteZeroX    d0
  1662.         SbcA    4
  1663.  
  1664. SBCAbs        ReadByteAbs
  1665.         SbcA    4
  1666.  
  1667. SBCAbsX        ReadByteAbsX
  1668.         SbcA    4
  1669.  
  1670. SBCAbsY        ReadByteAbsY
  1671.         SbcA    4
  1672.  
  1673. SBCIndX        ReadByteIndX
  1674.         SbcA    6
  1675.  
  1676. SBCIndY        ReadByteIndY
  1677.         SbcA    5
  1678.  
  1679. Increment    MACRO    ;Zyklenzahl
  1680.         move.l    d0,-(sp)
  1681.         ReadByte
  1682.         addq.b    #1,d0
  1683.         move    ccr,RCCR
  1684.         move.b    d0,d1
  1685.         move.l    (sp)+,d0
  1686.         WriteByte
  1687.         Next    \1
  1688.         ENDM
  1689.  
  1690. IncrementZero    MACRO    ;Zyklenzahl
  1691.         addq.b    #1,(RAMPTR,d0.w)
  1692.         move    ccr,RCCR
  1693.         cmp.b    #2,d0
  1694.         bhs    \@1$
  1695.         NewConfig
  1696. \@1$        Next    \1
  1697.         ENDM
  1698.  
  1699. INCZero        ReadAdrZero
  1700.         IncrementZero    5
  1701.  
  1702. INCZeroX    ReadAdrZeroX
  1703.         IncrementZero    6
  1704.  
  1705. INCAbs        ReadAdrAbs
  1706.         Increment    6
  1707.  
  1708. INCAbsX        ReadAdrAbsX
  1709.         Increment    7
  1710.  
  1711. Decrement    MACRO    ;Zyklenzahl
  1712.         move.l    d0,-(sp)
  1713.         ReadByte
  1714.         subq.b    #1,d0
  1715.         move    ccr,RCCR
  1716.         move.b    d0,d1
  1717.         move.l    (sp)+,d0
  1718.         WriteByte
  1719.         Next    \1
  1720.         ENDM
  1721.  
  1722. DecrementZero    MACRO    ;Zyklenzahl
  1723.         subq.b    #1,(RAMPTR,d0.w)
  1724.         move    ccr,RCCR
  1725.         cmp.b    #2,d0
  1726.         bhs    \@1$
  1727.         NewConfig
  1728. \@1$        Next    \1
  1729.         ENDM
  1730.  
  1731. DECZero        ReadAdrZero
  1732.         DecrementZero    5
  1733.         
  1734. DECZeroX    ReadAdrZeroX
  1735.         DecrementZero    6
  1736.  
  1737. DECAbs        ReadAdrAbs
  1738.         Decrement    6
  1739.  
  1740. DECAbsX        ReadAdrAbsX
  1741.         Decrement    7
  1742.  
  1743. INX        addq.b    #1,RX
  1744.         move    ccr,RCCR
  1745.         Next    2
  1746.  
  1747. DEX        subq.b    #1,RX
  1748.         move    ccr,RCCR
  1749.         Next    2
  1750.  
  1751. INY        addq.b    #1,RY
  1752.         move    ccr,RCCR
  1753.         Next    2
  1754.  
  1755. DEY        subq.b    #1,RY
  1756.         move    ccr,RCCR
  1757.         Next    2
  1758.  
  1759. ; Logische Operationen
  1760. AndA        MACRO    ;Quelle, Zyklenzahl
  1761.         and.b    \1,RA
  1762.         move    ccr,RCCR
  1763.         Next    \2
  1764.         ENDM
  1765.  
  1766. ANDImm        AndA    (RPC)+,2
  1767.  
  1768. ANDZero        ReadAdrZero
  1769.         AndA    (RAMPTR,d0.w),3
  1770.  
  1771. ANDZeroX    ReadAdrZeroX
  1772.         AndA    (RAMPTR,d0.w),4
  1773.  
  1774. ANDAbs        ReadByteAbs
  1775.         AndA    d0,4
  1776.  
  1777. ANDAbsX        ReadByteAbsX
  1778.         AndA    d0,4
  1779.  
  1780. ANDAbsY        ReadByteAbsY
  1781.         AndA    d0,4
  1782.  
  1783. ANDIndX        ReadByteIndX
  1784.         AndA    d0,6
  1785.  
  1786. ANDIndY        ReadByteIndY
  1787.         AndA    d0,5
  1788.  
  1789. OrA        MACRO    ;Quelle, Zyklenzahl
  1790.         or.b    \1,RA
  1791.         move    ccr,RCCR
  1792.         Next    \2
  1793.         ENDM
  1794.  
  1795. ORAImm        OrA    (RPC)+,2
  1796.  
  1797. ORAZero        ReadAdrZero
  1798.         OrA    (RAMPTR,d0.w),3
  1799.  
  1800. ORAZeroX    ReadAdrZeroX
  1801.         OrA    (RAMPTR,d0.w),4
  1802.  
  1803. ORAAbs        ReadByteAbs
  1804.         OrA    d0,4
  1805.  
  1806. ORAAbsX        ReadByteAbsX
  1807.         OrA    d0,4
  1808.  
  1809. ORAAbsY        ReadByteAbsY
  1810.         OrA    d0,4
  1811.  
  1812. ORAIndX        ReadByteIndX
  1813.         OrA    d0,6
  1814.  
  1815. ORAIndY        ReadByteIndY
  1816.         OrA    d0,5
  1817.  
  1818. EorA        MACRO    ;Zyklenzahl
  1819.         eor.b    d0,RA        ;eor.b (ea),RA geht nicht
  1820.         move    ccr,RCCR    ;(Warum nicht, Motorola ?) :-(
  1821.         Next    \1
  1822.         ENDM
  1823.  
  1824. EORImm        move.b    (RPC)+,d0
  1825.         EorA    2
  1826.  
  1827. EORZero        ReadAdrZero
  1828.         move.b    (RAMPTR,d0.w),d0
  1829.         EorA    3
  1830.  
  1831. EORZeroX    ReadAdrZeroX
  1832.         move.b    (RAMPTR,d0.w),d0
  1833.         EorA    4
  1834.  
  1835. EORAbs        ReadByteAbs
  1836.         EorA    4
  1837.  
  1838. EORAbsX        ReadByteAbsX
  1839.         EorA    4
  1840.  
  1841. EORAbsY        ReadByteAbsY
  1842.         EorA    4
  1843.  
  1844. EORIndX        ReadByteIndX
  1845.         EorA    6
  1846.  
  1847. EORIndY        ReadByteIndY
  1848.         EorA    5
  1849.  
  1850. BitTest        MACRO    ;Zyklenzahl
  1851.         tst.b    d0        ;N holen
  1852.         move    ccr,RCCR
  1853.         and.w    #$1cff,RP    ;B,D,I und C behalten
  1854.  
  1855.         btst    #6,d0        ;Bit 6 -> V
  1856.         beq    \@1$
  1857.         or.w    #OverflowMask,RP
  1858.  
  1859. \@1$        and.b    RA,d0        ;A AND M -> Z
  1860.         beq    \@2$
  1861.         and.b    #$fb,RCCR
  1862.         Next    \1
  1863. \@2$        or.b    #$04,RCCR
  1864.         Next    \1
  1865.         ENDM
  1866.  
  1867. BITZero        ReadByteZero    d0
  1868.         BitTest    3
  1869.  
  1870. BITAbs        ReadByteAbs
  1871.         BitTest    4
  1872.  
  1873. ; Verschiebungen
  1874. ShiftLeft    MACRO    ;Zyklenzahl
  1875.         move.l    d0,-(sp)
  1876.         ReadByte
  1877.         add.b    d0,d0
  1878.         move    ccr,RCCR
  1879.         move.b    RCCR,RP        ;Carry holen
  1880.         move.b    d0,d1
  1881.         move.l    (sp)+,d0
  1882.         WriteByte
  1883.         Next    \1
  1884.         ENDM
  1885.  
  1886. ShiftLeftZero    MACRO    ;Zyklenzahl
  1887.         lea    (RAMPTR,d0.w),a0
  1888.         move.b    (a0),d1
  1889.         add.b    d1,d1
  1890.         move    ccr,RCCR
  1891.         move.b    RCCR,RP        ;Carry holen
  1892.         move.b    d1,(a0)
  1893.         cmp.b    #2,d0
  1894.         bhs    \@1$
  1895.         NewConfig
  1896. \@1$        Next    \1
  1897.         ENDM
  1898.  
  1899. ASLA        add.b    RA,RA
  1900.         move    ccr,RCCR
  1901.         move.b    RCCR,RP        ;Carry holen
  1902.         Next    2
  1903.  
  1904. ASLZero        ReadAdrZero
  1905.         ShiftLeftZero    5
  1906.  
  1907. ASLZeroX    ReadAdrZeroX
  1908.         ShiftLeftZero    6
  1909.  
  1910. ASLAbs        ReadAdrAbs
  1911.         ShiftLeft    6
  1912.  
  1913. ASLAbsX        ReadAdrAbsX
  1914.         ShiftLeft    7
  1915.  
  1916. ShiftRight    MACRO    ;Zyklenzahl
  1917.         move.l    d0,-(sp)
  1918.         ReadByte
  1919.         lsr.b    #1,d0
  1920.         move    ccr,RCCR
  1921.         move.b    RCCR,RP        ;Carry holen
  1922.         move.b    d0,d1
  1923.         move.l    (sp)+,d0
  1924.         WriteByte
  1925.         Next    \1
  1926.         ENDM
  1927.  
  1928. ShiftRightZero    MACRO    ;Zyklenzahl
  1929.         lea    (RAMPTR,d0.w),a0
  1930.         move.b    (a0),d1
  1931.         lsr.b    #1,d1
  1932.         move    ccr,RCCR
  1933.         move.b    RCCR,RP        ;Carry holen
  1934.         move.b    d1,(a0)
  1935.         cmp.b    #2,d0
  1936.         bhs    \@1$
  1937.         NewConfig
  1938. \@1$        Next    \1
  1939.         ENDM
  1940.  
  1941. LSRA        lsr.b    #1,RA
  1942.         move    ccr,RCCR
  1943.         move.b    RCCR,RP        ;Carry holen
  1944.         Next    2
  1945.  
  1946. LSRZero        ReadAdrZero
  1947.         ShiftRightZero    5
  1948.  
  1949. LSRZeroX    ReadAdrZeroX
  1950.         ShiftRightZero    6
  1951.  
  1952. LSRAbs        ReadAdrAbs
  1953.         ShiftRight    6
  1954.  
  1955. LSRAbsX        ReadAdrAbsX
  1956.         ShiftRight    7
  1957.  
  1958. RotateLeft    MACRO    ;Zyklenzahl
  1959.         move.l    d0,-(sp)
  1960.         ReadByte
  1961.         lsr.b    #1,RP        ;Carry -> X
  1962.         roxl.b    #1,d0
  1963.         move    ccr,RCCR
  1964.         move.b    RCCR,RP        ;Carry holen
  1965.         move.b    d0,d1
  1966.         move.l    (sp)+,d0
  1967.         WriteByte
  1968.         Next    \1
  1969.         ENDM
  1970.  
  1971. RotateLeftZero    MACRO    ;Zyklenzahl
  1972.         lea    (RAMPTR,d0.w),a0
  1973.         move.b    (a0),d1
  1974.         lsr.b    #1,RP        ;Carry -> X
  1975.         roxl.b    #1,d1
  1976.         move    ccr,RCCR
  1977.         move.b    RCCR,RP        ;Carry holen
  1978.         move.b    d1,(a0)
  1979.         cmp.b    #2,d0
  1980.         bhs    \@1$
  1981.         NewConfig
  1982. \@1$        Next    \1
  1983.         ENDM
  1984.  
  1985. ROLA        lsr.b    #1,RP        ;Carry -> X
  1986.         roxl.b    #1,RA
  1987.         move    ccr,RCCR
  1988.         move.b    RCCR,RP        ;Carry holen
  1989.         Next    2
  1990.  
  1991. ROLZero        ReadAdrZero
  1992.         RotateLeftZero    5
  1993.  
  1994. ROLZeroX    ReadAdrZeroX
  1995.         RotateLeftZero    6
  1996.  
  1997. ROLAbs        ReadAdrAbs
  1998.         RotateLeft    6
  1999.  
  2000. ROLAbsX        ReadAdrAbsX
  2001.         RotateLeft    7
  2002.  
  2003. RotateRight    MACRO    ;Zyklenzahl
  2004.         move.l    d0,-(sp)
  2005.         ReadByte
  2006.         lsr.b    #1,RP        ;Carry -> X
  2007.         roxr.b    #1,d0
  2008.         move    ccr,RCCR
  2009.         move.b    RCCR,RP        ;Carry holen
  2010.         move.b    d0,d1
  2011.         move.l    (sp)+,d0
  2012.         WriteByte
  2013.         Next    \1
  2014.         ENDM
  2015.  
  2016. RotateRightZero    MACRO    ;Zyklenzahl
  2017.         lea    (RAMPTR,d0.w),a0
  2018.         move.b    (a0),d1
  2019.         lsr.b    #1,RP        ;Carry -> X
  2020.         roxr.b    #1,d1
  2021.         move    ccr,RCCR
  2022.         move.b    RCCR,RP        ;Carry holen
  2023.         move.b    d1,(a0)
  2024.         cmp.b    #2,d0
  2025.         bhs    \@1$
  2026.         NewConfig
  2027. \@1$        Next    \1
  2028.         ENDM
  2029.  
  2030. RORA        lsr.b    #1,RP        ;Carry -> X
  2031.         roxr.b    #1,RA
  2032.         move    ccr,RCCR
  2033.         move.b    RCCR,RP        ;Carry holen
  2034.         Next    2
  2035.  
  2036. RORZero        ReadAdrZero
  2037.         RotateRightZero    5
  2038.  
  2039. RORZeroX    ReadAdrZeroX
  2040.         RotateRightZero    6
  2041.  
  2042. RORAbs        ReadAdrAbs
  2043.         RotateRight    6
  2044.  
  2045. RORAbsX        ReadAdrAbsX
  2046.         RotateRight    7
  2047.  
  2048. ; Sprünge/Verzweigungen
  2049. JMPAbs        ReadAdrAbs
  2050.         Jump
  2051.         Next    3
  2052.  
  2053. JMPInd        ReadAdrInd
  2054.         Jump
  2055.         Next    5
  2056.  
  2057. JSRAbs        PushPCPlus1
  2058.         ReadAdrAbs
  2059.         Jump
  2060.         Next    6
  2061.  
  2062. RTSImpl        PopByte    d1        ;LSB
  2063.         PopByte    d0        ;MSB
  2064.         lsl.w    #8,d0        ;schieben
  2065.         move.b    d1,d0        ;LSB dazunehmen
  2066.         addq.w    #1,d0        ;Adresse um eins erhöhen
  2067.         Jump
  2068.         Next    6
  2069.  
  2070. RTIImpl        PopP
  2071.         PopByte    d1        ;LSB
  2072.         PopByte    d0        ;MSB
  2073.         lsl.w    #8,d0        ;schieben
  2074.         move.b    d1,d0        ;LSB dazunehmen
  2075.         Jump
  2076.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2077.         beq    1$
  2078.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  2079.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  2080. 1$        Next    6
  2081.  
  2082. BRK        PushPC
  2083.         or.w    #BreakMask,RP    ;Break-Flag nur auf dem Stapel setzen
  2084.         PushP
  2085.         and.w    #~BreakMask,RP
  2086.         or.w    #InterruptMask,RP
  2087.         move.w    #$fffe,d0    ;IRQ-Vektor
  2088.         ReadWord
  2089.         Jump
  2090.         Next    7
  2091.  
  2092. Branch        MACRO
  2093.         ReadByteRel
  2094.         move.l    RPC,d1
  2095.         add.w    d0,d1
  2096.         move.l    d1,RPC
  2097.         moveq    #0,d1
  2098.         Next    3
  2099.         ENDM
  2100.  
  2101. BVCRel        btst    #OverflowBit,RP
  2102.         bne    BVCNot
  2103.         Branch
  2104. BVCNot        addq.l    #1,RPC
  2105.         Next    2
  2106.  
  2107. BVSRel        btst    #OverflowBit,RP
  2108.         beq    BVSNot
  2109.         Branch
  2110. BVSNot        addq.l    #1,RPC
  2111.         Next    2
  2112.  
  2113. BEQRel        btst    #2,RCCR
  2114.         beq    BEQNot
  2115.         Branch
  2116. BEQNot        addq.l    #1,RPC
  2117.         Next    2
  2118.  
  2119. BNERel        btst    #2,RCCR
  2120.         bne    BNENot
  2121.         Branch
  2122. BNENot        addq.l    #1,RPC
  2123.         Next    2
  2124.  
  2125. BPLRel        btst    #3,RCCR
  2126.         bne    BPLNot
  2127.         Branch
  2128. BPLNot        addq.l    #1,RPC
  2129.         Next    2
  2130.  
  2131. BMIRel        btst    #3,RCCR
  2132.         beq    BMINot
  2133.         Branch
  2134. BMINot        addq.l    #1,RPC
  2135.         Next    2
  2136.  
  2137. BCCRel        btst    #CarryBit,RP
  2138.         bne    BCCNot
  2139.         Branch
  2140. BCCNot        addq.l    #1,RPC
  2141.         Next    2
  2142.  
  2143. BCSRel        btst    #CarryBit,RP
  2144.         beq    BCSNot
  2145.         Branch
  2146. BCSNot        addq.l    #1,RPC
  2147.         Next    2
  2148.  
  2149. ; Statusregister
  2150. SEI        or.w    #InterruptMask,RP
  2151.         Next    2
  2152.  
  2153. CLI        and.w    #~InterruptMask,RP
  2154.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2155.         bne    HandleIRQ    ;Ja, auslösen
  2156.         Next    2
  2157.  
  2158. CLC        clr.b    RP
  2159.         Next    2
  2160.  
  2161. SEC        st.b    RP
  2162.         Next    2
  2163.  
  2164. SED        or.w    #DecimalMask,RP
  2165.         Next    2
  2166.  
  2167. CLD        and.w    #~DecimalMask,RP
  2168.         Next    2
  2169.  
  2170. CLV        and.w    #~OverflowMask,RP
  2171.         Next    2
  2172.  
  2173. *
  2174. * Periodic: Wird über den Opcode-Fetch aufgerufen,
  2175. *  wenn der Zyklenzähler unterläuft
  2176. * Sitzt hier in der Mitte, um kurze Branches ausnutzen zu können
  2177. *
  2178.  
  2179. ; VIC und CIA aufrufen
  2180. Periodic    lea    RegStore+24,a0
  2181.         movem.w    d2-d7,-(a0)    ;Gerade Anzahl von Registern
  2182.         movem.l    a2-a3/a5,-(a0)
  2183.         bra    Periodic6569    ;Springt nach Periodic6526 und hierher zurück
  2184. Peri6526Cont    movem.l    RegStore,a2-a3/a5
  2185.         movem.w    RegStore+12,d2-d7
  2186.         move.l    TheRAM,RAMPTR        ;a4
  2187.         lea    OpcodeTable,OPTABPTR    ;a6
  2188.         moveq    #0,d0
  2189.         moveq    #0,d1
  2190.  
  2191. ; Interrupt aufgetreten?
  2192.         tst.l    Interrupt(pc)
  2193.         bne    HandleInt
  2194.  
  2195. ; Nein, Nächsten Befehl ausführen
  2196.         Next    0
  2197.  
  2198.  
  2199. ; Leerbefehle
  2200. NOPImpl        Next    2
  2201.  
  2202. NOPZero        addq.w    #1,RPC
  2203.         Next    3
  2204.  
  2205. NOPZeroX    addq.w    #1,RPC
  2206.         Next    4
  2207.  
  2208. NOPAbsX
  2209. NOPAbs        addq.w    #2,RPC
  2210.         Next    4
  2211.  
  2212. ; ASL/ORA-Gruppe
  2213. ShLeftOr    MACRO    ;Zyklenzahl
  2214.         move.l    d0,-(sp)
  2215.         ReadByte
  2216.         add.b    d0,d0
  2217.         move    ccr,RCCR
  2218.         move.b    RCCR,RP        ;Carry holen
  2219.         or.b    d0,RA
  2220.         move.b    d0,d1
  2221.         move.l    (sp)+,d0
  2222.         WriteByte
  2223.         Next    \1
  2224.         ENDM
  2225.  
  2226. ShLeftOrZero    MACRO    ;Zyklenzahl
  2227.         lea    (RAMPTR,d0.w),a0
  2228.         move.b    (a0),d1
  2229.         add.b    d1,d1
  2230.         move    ccr,RCCR
  2231.         move.b    RCCR,RP        ;Carry holen
  2232.         or.b    d1,RA
  2233.         move.b    d1,(a0)
  2234.         cmp.b    #2,d0
  2235.         bhs    \@1$
  2236.         NewConfig
  2237. \@1$        Next    \1
  2238.         ENDM
  2239.  
  2240. SLOZero        ReadAdrZero
  2241.         ShLeftOrZero    5
  2242.  
  2243. SLOZeroX    ReadAdrZeroX
  2244.         ShLeftOrZero    6
  2245.  
  2246. SLOAbs        ReadAdrAbs
  2247.         ShLeftOr    6
  2248.  
  2249. SLOAbsX        ReadAdrAbsX
  2250.         ShLeftOr    7
  2251.  
  2252. SLOAbsY        ReadAdrAbsY
  2253.         ShLeftOr    7
  2254.  
  2255. SLOIndX        ReadAdrIndX
  2256.         ShLeftOr    8
  2257.  
  2258. SLOIndY        ReadAdrIndY
  2259.         ShLeftOr    8
  2260.  
  2261. ; ROL/AND-Gruppe
  2262. RoLeftAnd    MACRO    ;Zyklenzahl
  2263.         move.l    d0,-(sp)
  2264.         ReadByte
  2265.         lsr.b    #1,RP        ;Carry -> X
  2266.         roxl.b    #1,d0
  2267.         move    ccr,RCCR
  2268.         move.b    RCCR,RP        ;Carry holen
  2269.         and.b    d0,RA
  2270.         move    ccr,RCCR    ;N und Z holen
  2271.         move.b    d0,d1
  2272.         move.l    (sp)+,d0
  2273.         WriteByte
  2274.         Next    \1
  2275.         ENDM
  2276.  
  2277. RoLeftAndZero    MACRO    ;Zyklenzahl
  2278.         lea    (RAMPTR,d0.w),a0
  2279.         move.b    (a0),d1
  2280.         lsr.b    #1,RP        ;Carry -> X
  2281.         roxl.b    #1,d1
  2282.         move    ccr,RCCR
  2283.         move.b    RCCR,RP        ;Carry holen
  2284.         and.b    d1,RA
  2285.         move    ccr,RCCR    ;N und Z holen
  2286.         move.b    d1,(a0)
  2287.         cmp.b    #2,d0
  2288.         bhs    \@1$
  2289.         NewConfig
  2290. \@1$        Next    \1
  2291.         ENDM
  2292.  
  2293. RLAZero        ReadAdrZero
  2294.         RoLeftAndZero    5
  2295.  
  2296. RLAZeroX    ReadAdrZeroX
  2297.         RoLeftAndZero    6
  2298.  
  2299. RLAAbs        ReadAdrAbs
  2300.         RoLeftAnd    6
  2301.  
  2302. RLAAbsX        ReadAdrAbsX
  2303.         RoLeftAnd    7
  2304.  
  2305. RLAAbsY        ReadAdrAbsY
  2306.         RoLeftAnd    7
  2307.  
  2308. RLAIndX        ReadAdrIndX
  2309.         RoLeftAnd    8
  2310.  
  2311. RLAIndY        ReadAdrIndY
  2312.         RoLeftAnd    8
  2313.  
  2314. ; LSR/EOR-Gruppe
  2315. ShRightEor    MACRO    ;Zyklenzahl
  2316.         move.l    d0,-(sp)
  2317.         ReadByte
  2318.         lsr.b    #1,d0
  2319.         move    ccr,RCCR
  2320.         move.b    RCCR,RP        ;Carry holen
  2321.         eor.b    d0,RA
  2322.         move.b    d0,d1
  2323.         move.l    (sp)+,d0
  2324.         WriteByte
  2325.         Next    \1
  2326.         ENDM
  2327.  
  2328. ShRightEorZero    MACRO    ;Zyklenzahl
  2329.         lea    (RAMPTR,d0.w),a0
  2330.         move.b    (a0),d1
  2331.         lsr.b    #1,d1
  2332.         move    ccr,RCCR
  2333.         move.b    RCCR,RP        ;Carry holen
  2334.         eor.b    d1,RA
  2335.         move.b    d1,(a0)
  2336.         cmp.b    #2,d0
  2337.         bhs    \@1$
  2338.         NewConfig
  2339. \@1$        Next    \1
  2340.         ENDM
  2341.  
  2342. SREZero        ReadAdrZero
  2343.         ShRightEorZero    5
  2344.  
  2345. SREZeroX    ReadAdrZeroX
  2346.         ShRightEorZero    6
  2347.  
  2348. SREAbs        ReadAdrAbs
  2349.         ShRightEor    6
  2350.  
  2351. SREAbsX        ReadAdrAbsX
  2352.         ShRightEor    7
  2353.  
  2354. SREAbsY        ReadAdrAbsY
  2355.         ShRightEor    7
  2356.  
  2357. SREIndX        ReadAdrIndX
  2358.         ShRightEor    8
  2359.  
  2360. SREIndY        ReadAdrIndY
  2361.         ShRightEor    8
  2362.  
  2363. ; ROR/ADC-Gruppe
  2364. RoRightAdc    MACRO    ;Zyklenzahl
  2365.         move.l    d0,-(sp)
  2366.         ReadByte
  2367.         lsr.b    #1,RP        ;Carry -> X
  2368.         roxr.b    #1,d0
  2369.         move    ccr,RCCR
  2370.         move.b    RCCR,RP        ;Carry holen
  2371.         lsr.b    #1,RP        ;Carry -> X
  2372.         addx.b    d0,RA
  2373.         move    ccr,RCCR
  2374.         bvc    \@2$        ;Overflow holen
  2375.         or.w    #OverflowMask,RP
  2376.         bra    \@3$
  2377. \@2$        and.w    #~OverflowMask,RP
  2378. \@3$        move.b    RCCR,RP        ;Carry holen
  2379.         move.b    d0,d1
  2380.         move.l    (sp)+,d0
  2381.         WriteByte
  2382.         Next    \1
  2383.         ENDM
  2384.  
  2385. RoRightAdcZero    MACRO    ;Zyklenzahl
  2386.         lea    (RAMPTR,d0.w),a0
  2387.         move.b    (a0),d1
  2388.         lsr.b    #1,RP        ;Carry -> X
  2389.         roxr.b    #1,d1
  2390.         move    ccr,RCCR
  2391.         move.b    RCCR,RP        ;Carry holen
  2392.         lsr.b    #1,RP        ;Carry -> X
  2393.         addx.b    d1,RA
  2394.         move    ccr,RCCR
  2395.         bvc    \@2$        ;Overflow holen
  2396.         or.w    #OverflowMask,RP
  2397.         bra    \@3$
  2398. \@2$        and.w    #~OverflowMask,RP
  2399. \@3$        move.b    RCCR,RP        ;Carry holen
  2400.         move.b    d1,(a0)
  2401.         cmp.b    #2,d0
  2402.         bhs    \@1$
  2403.         NewConfig
  2404. \@1$        Next    \1
  2405.         ENDM
  2406.  
  2407. RRAZero        ReadAdrZero
  2408.         RoRightAdcZero    5
  2409.  
  2410. RRAZeroX    ReadAdrZeroX
  2411.         RoRightAdcZero    6
  2412.  
  2413. RRAAbs        ReadAdrAbs
  2414.         RoRightAdc    6
  2415.  
  2416. RRAAbsX        ReadAdrAbsX
  2417.         RoRightAdc    7
  2418.  
  2419. RRAAbsY        ReadAdrAbsY
  2420.         RoRightAdc    7
  2421.  
  2422. RRAIndX        ReadAdrIndX
  2423.         RoRightAdc    8
  2424.  
  2425. RRAIndY        ReadAdrIndY
  2426.         RoRightAdc    8
  2427.  
  2428. ; DEC/CMP-Gruppe
  2429. DecCompare    MACRO    ;Zyklenzahl
  2430.         move.l    d0,-(sp)
  2431.         ReadByte
  2432.         subq.b    #1,d0
  2433.         cmp.b    d0,RA
  2434.         move    ccr,RCCR
  2435.         move.b    RCCR,RP        ;Carry holen und invertieren
  2436.         not.b    RP
  2437.         move.b    d0,d1
  2438.         move.l    (sp)+,d0
  2439.         WriteByte
  2440.         Next    \1
  2441.         ENDM
  2442.  
  2443. DecCompareZero    MACRO    ;Zyklenzahl
  2444.         lea    (RAMPTR,d0.w),a0
  2445.         move.b    (a0),d1
  2446.         subq.b    #1,d1
  2447.         cmp.b    d1,RA
  2448.         move    ccr,RCCR
  2449.         move.b    RCCR,RP        ;Carry holen und invertieren
  2450.         not.b    RP
  2451.         move.b    d1,(a0)
  2452.         cmp.b    #2,d0
  2453.         bhs    \@1$
  2454.         NewConfig
  2455. \@1$        Next    \1
  2456.         ENDM
  2457.  
  2458. DCPZero        ReadAdrZero
  2459.         DecCompareZero    5
  2460.  
  2461. DCPZeroX    ReadAdrZeroX
  2462.         DecCompareZero    6
  2463.  
  2464. DCPAbs        ReadAdrAbs
  2465.         DecCompare    6
  2466.  
  2467. DCPAbsX        ReadAdrAbsX
  2468.         DecCompare    7
  2469.  
  2470. DCPAbsY        ReadAdrAbsY
  2471.         DecCompare    7
  2472.  
  2473. DCPIndX        ReadAdrIndX
  2474.         DecCompare    8
  2475.  
  2476. DCPIndY        ReadAdrIndY
  2477.         DecCompare    8
  2478.  
  2479. ; INC/SBC-Gruppe
  2480. IncSbc        MACRO    ;Zyklenzahl
  2481.         move.l    d0,-(sp)
  2482.         ReadByte
  2483.         addq.b    #1,d0
  2484.         not.b    RP
  2485.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2486.         subx.b    d0,RA
  2487.         move    ccr,RCCR
  2488.         bvc    \@2$        ;Overflow holen
  2489.         or.w    #OverflowMask,RP
  2490.         bra    \@3$
  2491. \@2$        and.w    #~OverflowMask,RP
  2492. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2493.         not.b    RP
  2494.         move.b    d0,d1
  2495.         move.l    (sp)+,d0
  2496.         WriteByte
  2497.         Next    \1
  2498.         ENDM
  2499.  
  2500. IncSbcZero    MACRO    ;Zyklenzahl
  2501.         lea    (RAMPTR,d0.w),a0
  2502.         move.b    (a0),d1
  2503.         addq.b    #1,d1
  2504.         not.b    RP
  2505.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2506.         subx.b    d1,RA
  2507.         move    ccr,RCCR
  2508.         bvc    \@2$        ;Overflow holen
  2509.         or.w    #OverflowMask,RP
  2510.         bra    \@3$
  2511. \@2$        and.w    #~OverflowMask,RP
  2512. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2513.         not.b    RP
  2514.         move.b    d1,(a0)
  2515.         cmp.b    #2,d0
  2516.         bhs    \@1$
  2517.         NewConfig
  2518. \@1$        Next    \1
  2519.         ENDM
  2520.  
  2521. ISBZero        ReadAdrZero
  2522.         IncSbcZero    5
  2523.  
  2524. ISBZeroX    ReadAdrZeroX
  2525.         IncSbcZero    6
  2526.  
  2527. ISBAbs        ReadAdrAbs
  2528.         IncSbc    6
  2529.  
  2530. ISBAbsX        ReadAdrAbsX
  2531.         IncSbc    7
  2532.  
  2533. ISBAbsY        ReadAdrAbsY
  2534.         IncSbc    7
  2535.  
  2536. ISBIndX        ReadAdrIndX
  2537.         IncSbc    8
  2538.  
  2539. ISBIndY        ReadAdrIndY
  2540.         IncSbc    8
  2541.  
  2542. ; Komplexe (undokumentierte) Funktionen
  2543. ANCImm        and.b    (RPC)+,RA    ;??? ($0b, $2b)
  2544.         move    ccr,RCCR
  2545.         smi.b    RP        ;N -> C
  2546.         Next    2
  2547.  
  2548. ASRImm        and.b    (RPC)+,RA
  2549.         lsr.b    #1,RA
  2550.         move    ccr,RCCR
  2551.         move.b    RCCR,RP
  2552.         Next    2
  2553.  
  2554. ARRImm        and.b    (RPC)+,RA
  2555.         lsr.b    #1,RP        ;Carry -> X
  2556.         roxr.b    #1,RA
  2557.         move    ccr,RCCR
  2558.         move.b    RCCR,RP        ;Carry holen
  2559.         Next    2
  2560.  
  2561. ANEImm        or.b    #$ee,RA
  2562.         and.b    (RPC)+,RA
  2563.         and.b    RX,RA
  2564.         move    ccr,RCCR
  2565.         Next    2
  2566.  
  2567. LXAImm        and.b    (RPC)+,RA
  2568.         move.b    RA,RX
  2569.         move    ccr,RCCR
  2570.         Next    2
  2571.  
  2572. LASAbsY        ReadByteAbsY        ;??? ($bb)
  2573.         and.b    RS,d0
  2574.         move.b    d0,RX
  2575.         move.b    d0,RA
  2576.         move    ccr,RCCR
  2577.         Next    4
  2578.  
  2579. SHAAbsY        ReadPCWord
  2580.         move.w    d0,d1
  2581.         lsr.w    #8,d1
  2582.         addq.b    #1,d1
  2583.         and.b    RX,d1
  2584.         and.b    RA,d1
  2585.         add.w    RY,d0
  2586.         WriteByte
  2587.         Next    5
  2588.  
  2589. SHAIndY        moveq    #0,d0
  2590.         move.b    (RPC)+,d0
  2591.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  2592.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  2593.         move.w    d0,d1
  2594.         lsr.w    #8,d1
  2595.         addq.b    #1,d1
  2596.         and.b    RX,d1
  2597.         and.b    RA,d1
  2598.         add.w    RY,d0
  2599.         WriteByte
  2600.         Next    6
  2601.  
  2602. SHXAbsY        ReadPCWord
  2603.         move.w    d0,d1
  2604.         lsr.w    #8,d1
  2605.         addq.b    #1,d1
  2606.         and.b    RY,d1
  2607.         add.w    RY,d0
  2608.         WriteByte
  2609.         Next    5
  2610.  
  2611. SHYAbsX        ReadPCWord
  2612.         move.w    d0,d1
  2613.         lsr.w    #8,d1
  2614.         addq.b    #1,d1
  2615.         and.b    RX,d1
  2616.         add.w    RX,d0
  2617.         WriteByte
  2618.         Next    5
  2619.  
  2620. SHSAbsY        move.b    RA,RS
  2621.         and.b    RX,RS
  2622.         ReadPCWord
  2623.         move.w    d0,d1
  2624.         lsr.w    #8,d1
  2625.         addq.b    #1,d1
  2626.         and.b    RS,d1
  2627.         WriteByte
  2628.         Next    5
  2629.  
  2630. SBXImm        and.b    RA,RX
  2631.         sub.b    (RPC)+,RX
  2632.         move    ccr,RCCR
  2633.         move.b    RCCR,RP        ;Carry holen und invertieren
  2634.         not.b    RP
  2635.         Next    2
  2636.  
  2637. *
  2638. * Erweiterte Opcodes
  2639. *
  2640.  
  2641. ; $d2
  2642. OpWrap        move.l    RPC,d1        ;Wraparound nach $100xx?
  2643.         sub.l    RAMPTR,d1
  2644.         swap    d1
  2645.         cmp.w    #1,d1
  2646.         bne    IllegalOp
  2647.         sub.l    #$10001,RPC    ;Ja, zu $00xx umleiten
  2648.         moveq    #0,d1
  2649.         Next    0
  2650.  
  2651. ; $f2 $xx
  2652. OpIEC        move.b    (RPC)+,d0    ;Selektor holen
  2653.         beq    OpIECOut
  2654.         cmp.b    #1,d0
  2655.         beq    OpIECOutATN
  2656.         cmp.b    #2,d0
  2657.         beq    OpIECOutSec
  2658.         cmp.b    #3,d0
  2659.         beq    OpIECIn
  2660.         cmp.b    #4,d0
  2661.         beq    OpIECSetATN
  2662.         cmp.b    #5,d0
  2663.         beq    OpIECRelATN
  2664.         cmp.b    #6,d0
  2665.         beq    OpIECTurnaround
  2666.         cmp.b    #7,d0
  2667.         beq    OpIECRelease
  2668.         bra    IllegalOp
  2669.  
  2670. OpIECOut    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2671.         move.b    $a3(RAMPTR),d1    ;EOI-Flag holen
  2672.         bsr    IECOut
  2673.         bra    IECSetST
  2674.  
  2675. OpIECOutATN    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2676.         bsr    IECOutATN
  2677.         bra    IECSetST
  2678.  
  2679. OpIECOutSec    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2680.         bsr    IECOutSec
  2681.         bra    IECSetST
  2682.  
  2683. OpIECIn        bsr    IECIn
  2684.         move.b    d1,RA        ;Byte in den Akku
  2685.         move    ccr,RCCR    ;Flags entsprechend setzen
  2686.         bra    IECSetST
  2687.  
  2688. OpIECSetATN    bsr    IECSetATN
  2689.         moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2690.         moveq    #0,d1
  2691.         move.w    #$edfb,d0    ;Nach $edfb springen
  2692.         Jump
  2693.         Next    0
  2694.  
  2695. OpIECRelATN    bsr    IECRelATN
  2696.         bra    IECReturn
  2697.  
  2698. OpIECTurnaround    bsr    IECTurnaround
  2699.         bra    IECReturn
  2700.  
  2701. OpIECRelease    bsr    IECRelease
  2702.         bra    IECReturn
  2703.  
  2704. IECSetST    or.b    d0,$90(RAMPTR)    ;Status setzen
  2705.         clr.b    RP        ;Carry löschen
  2706. IECReturn    moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2707.         moveq    #0,d1
  2708.         bra    RTSImpl        ;RTS ausführen
  2709.  
  2710.  
  2711. **
  2712. ** Konstanten
  2713. **
  2714.  
  2715. ; Strings
  2716. CPUTaskName    dc.b    "6510",0
  2717. TimerIntName    dc.b    "Frodo Timer Int",0
  2718.  
  2719. IDString    dc.b    "FRODO V1.5",13
  2720.         dc.b    "(C)1994-1995 CHRISTIAN BAUER",0
  2721.         ds.b    64    ;Muß mind. 92 Zeichen lang sein
  2722.         CNOP    0,4
  2723.  
  2724.  
  2725. *
  2726. * Speicherkonfigurationstabelle
  2727. *
  2728.  
  2729. ; Diese Tabelle enthält für alle 8 Speicherkonfigurationen
  2730. ; die Zeiger auf die zugehörigen Read- und WriteTabs
  2731.         CNOP    0,4
  2732. ConfigTab    dc.l    ReadTab0,WriteTab0
  2733.         dc.l    ReadTab1,WriteTab1
  2734.         dc.l    ReadTab2,WriteTab2
  2735.         dc.l    ReadTab3,WriteTab3
  2736.         dc.l    ReadTab4,WriteTab4
  2737.         dc.l    ReadTab5,WriteTab5
  2738.         dc.l    ReadTab6,WriteTab6
  2739.         dc.l    ReadTab7,WriteTab7
  2740.  
  2741.  
  2742. *
  2743. * Opcode Dispatch Table
  2744. * "*" bezeichnet einen undokumentierten Opcode
  2745. *
  2746.  
  2747.         CNOP    0,4
  2748. OpcodeTable
  2749. CyclesLeft    dc.w    0    ;Anzahl zur Verfügung stehender CPU-Zyklen
  2750.                 ; bis zum nächsten Periodic
  2751.         dc.w    0
  2752.         dc.l    BRK        ;$00
  2753.         dc.l    ORAIndX
  2754.         dc.l    IllegalOp
  2755.         dc.l    SLOIndX        ;*
  2756.         dc.l    NOPZero        ;*
  2757.         dc.l    ORAZero
  2758.         dc.l    ASLZero
  2759.         dc.l    SLOZero        ;*
  2760.  
  2761.         dc.l    PHP        ;$08
  2762.         dc.l    ORAImm
  2763.         dc.l    ASLA
  2764.         dc.l    ANCImm        ;*
  2765.         dc.l    NOPAbs        ;*
  2766.         dc.l    ORAAbs
  2767.         dc.l    ASLAbs
  2768.         dc.l    SLOAbs        ;*
  2769.  
  2770.         dc.l    BPLRel        ;$10
  2771.         dc.l    ORAIndY
  2772.         dc.l    IllegalOp
  2773.         dc.l    SLOIndY        ;*
  2774.         dc.l    NOPZeroX    ;*
  2775.         dc.l    ORAZeroX
  2776.         dc.l    ASLZeroX
  2777.         dc.l    SLOZeroX    ;*
  2778.  
  2779.         dc.l    CLC        ;$18
  2780.         dc.l    ORAAbsY
  2781.         dc.l    NOPImpl        ;*
  2782.         dc.l    SLOAbsY        ;*
  2783.         dc.l    NOPAbsX        ;*
  2784.         dc.l    ORAAbsX
  2785.         dc.l    ASLAbsX
  2786.         dc.l    SLOAbsX
  2787.  
  2788.         dc.l    JSRAbs        ;$20
  2789.         dc.l    ANDIndX
  2790.         dc.l    IllegalOp
  2791.         dc.l    RLAIndX        ;*
  2792.         dc.l    BITZero
  2793.         dc.l    ANDZero
  2794.         dc.l    ROLZero
  2795.         dc.l    RLAZero        ;*
  2796.  
  2797.         dc.l    PLP        ;$28
  2798.         dc.l    ANDImm
  2799.         dc.l    ROLA
  2800.         dc.l    ANCImm        ;*
  2801.         dc.l    BITAbs
  2802.         dc.l    ANDAbs
  2803.         dc.l    ROLAbs
  2804.         dc.l    RLAAbs        ;*
  2805.  
  2806.         dc.l    BMIRel        ;$30
  2807.         dc.l    ANDIndY
  2808.         dc.l    IllegalOp
  2809.         dc.l    RLAIndY        ;*
  2810.         dc.l    NOPZeroX    ;*
  2811.         dc.l    ANDZeroX
  2812.         dc.l    ROLZeroX
  2813.         dc.l    RLAZeroX    ;*
  2814.  
  2815.         dc.l    SEC        ;$38
  2816.         dc.l    ANDAbsY
  2817.         dc.l    NOPImpl        ;*
  2818.         dc.l    RLAAbsY        ;*
  2819.         dc.l    NOPAbsX        ;*
  2820.         dc.l    ANDAbsX
  2821.         dc.l    ROLAbsX
  2822.         dc.l    RLAAbsX        ;*
  2823.  
  2824.         dc.l    RTIImpl        ;$40
  2825.         dc.l    EORIndX
  2826.         dc.l    IllegalOp
  2827.         dc.l    SREIndX        ;*
  2828.         dc.l    NOPZero        ;*
  2829.         dc.l    EORZero
  2830.         dc.l    LSRZero
  2831.         dc.l    SREZero        ;*
  2832.  
  2833.         dc.l    PHA        ;$48
  2834.         dc.l    EORImm
  2835.         dc.l    LSRA
  2836.         dc.l    ASRImm        ;*
  2837.         dc.l    JMPAbs
  2838.         dc.l    EORAbs
  2839.         dc.l    LSRAbs
  2840.         dc.l    SREAbs        ;*
  2841.  
  2842.         dc.l    BVCRel        ;$50
  2843.         dc.l    EORIndY
  2844.         dc.l    IllegalOp
  2845.         dc.l    SREIndY        ;*
  2846.         dc.l    NOPZeroX    ;*
  2847.         dc.l    EORZeroX
  2848.         dc.l    LSRZeroX
  2849.         dc.l    SREZeroX    ;*
  2850.  
  2851.         dc.l    CLI        ;$58
  2852.         dc.l    EORAbsY
  2853.         dc.l    NOPImpl        ;*
  2854.         dc.l    SREAbsY        ;*
  2855.         dc.l    NOPAbsX        ;*
  2856.         dc.l    EORAbsX
  2857.         dc.l    LSRAbsX
  2858.         dc.l    SREAbsX        ;*
  2859.  
  2860.         dc.l    RTSImpl        ;$60
  2861.         dc.l    ADCIndX
  2862.         dc.l    IllegalOp
  2863.         dc.l    RRAIndX        ;*
  2864.         dc.l    NOPZero        ;*
  2865.         dc.l    ADCZero
  2866.         dc.l    RORZero
  2867.         dc.l    RRAZero        ;*
  2868.  
  2869.         dc.l    PLA        ;$68
  2870.         dc.l    ADCImm
  2871.         dc.l    RORA
  2872.         dc.l    ARRImm        ;*
  2873.         dc.l    JMPInd
  2874.         dc.l    ADCAbs
  2875.         dc.l    RORAbs
  2876.         dc.l    RRAAbs        ;*
  2877.  
  2878.         dc.l    BVSRel        ;$70
  2879.         dc.l    ADCIndY
  2880.         dc.l    IllegalOp
  2881.         dc.l    RRAIndY        ;*
  2882.         dc.l    NOPZeroX    ;*
  2883.         dc.l    ADCZeroX
  2884.         dc.l    RORZeroX
  2885.         dc.l    RRAZeroX    ;*
  2886.  
  2887.         dc.l    SEI        ;$78
  2888.         dc.l    ADCAbsY
  2889.         dc.l    NOPImpl        ;*
  2890.         dc.l    RRAAbsY        ;*
  2891.         dc.l    NOPAbsX        ;*
  2892.         dc.l    ADCAbsX
  2893.         dc.l    RORAbsX
  2894.         dc.l    RRAAbsX        ;*
  2895.  
  2896.         dc.l    NOPZero        ;* $80
  2897.         dc.l    STAIndX
  2898.         dc.l    NOPZero        ;*
  2899.         dc.l    SAXIndX        ;*
  2900.         dc.l    STYZero
  2901.         dc.l    STAZero
  2902.         dc.l    STXZero
  2903.         dc.l    SAXZero        ;*
  2904.  
  2905.         dc.l    DEY        ;$88
  2906.         dc.l    NOPZero        ;*
  2907.         dc.l    TXA
  2908.         dc.l    ANEImm        ;*
  2909.         dc.l    STYAbs
  2910.         dc.l    STAAbs
  2911.         dc.l    STXAbs
  2912.         dc.l    SAXAbs        ;*
  2913.  
  2914.         dc.l    BCCRel        ;$90
  2915.         dc.l    STAIndY
  2916.         dc.l    IllegalOp
  2917.         dc.l    SHAIndY        ;*
  2918.         dc.l    STYZeroX
  2919.         dc.l    STAZeroX
  2920.         dc.l    STXZeroY
  2921.         dc.l    SAXZeroY    ;*
  2922.  
  2923.         dc.l    TYA        ;$98
  2924.         dc.l    STAAbsY
  2925.         dc.l    TXS
  2926.         dc.l    SHSAbsY        ;*
  2927.         dc.l    SHYAbsX        ;*
  2928.         dc.l    STAAbsX
  2929.         dc.l    SHXAbsY        ;*
  2930.         dc.l    SHAAbsY        ;*
  2931.  
  2932.         dc.l    LDYImm        ;$a0
  2933.         dc.l    LDAIndX
  2934.         dc.l    LDXImm
  2935.         dc.l    LAXIndX        ;*
  2936.         dc.l    LDYZero
  2937.         dc.l    LDAZero
  2938.         dc.l    LDXZero
  2939.         dc.l    LAXZero        ;*
  2940.  
  2941.         dc.l    TAY        ;$a8
  2942.         dc.l    LDAImm
  2943.         dc.l    TAX
  2944.         dc.l    LXAImm        ;*
  2945.         dc.l    LDYAbs
  2946.         dc.l    LDAAbs
  2947.         dc.l    LDXAbs
  2948.         dc.l    LAXAbs        ;*
  2949.  
  2950.         dc.l    BCSRel        ;$b0
  2951.         dc.l    LDAIndY
  2952.         dc.l    IllegalOp
  2953.         dc.l    LAXIndY        ;*
  2954.         dc.l    LDYZeroX
  2955.         dc.l    LDAZeroX
  2956.         dc.l    LDXZeroY
  2957.         dc.l    LAXZeroY    ;*
  2958.  
  2959.         dc.l    CLV        ;$b8
  2960.         dc.l    LDAAbsY
  2961.         dc.l    TSX
  2962.         dc.l    LASAbsY        ;*
  2963.         dc.l    LDYAbsX
  2964.         dc.l    LDAAbsX
  2965.         dc.l    LDXAbsY
  2966.         dc.l    LAXAbsY        ;*
  2967.  
  2968.         dc.l    CPYImm        ;$c0
  2969.         dc.l    CMPIndX
  2970.         dc.l    NOPZero        ;*
  2971.         dc.l    DCPIndX        ;*
  2972.         dc.l    CPYZero
  2973.         dc.l    CMPZero
  2974.         dc.l    DECZero
  2975.         dc.l    DCPZero        ;*
  2976.  
  2977.         dc.l    INY        ;$c8
  2978.         dc.l    CMPImm
  2979.         dc.l    DEX
  2980.         dc.l    SBXImm        ;*
  2981.         dc.l    CPYAbs
  2982.         dc.l    CMPAbs
  2983.         dc.l    DECAbs
  2984.         dc.l    DCPAbs        ;*
  2985.  
  2986.         dc.l    BNERel        ;$d0
  2987.         dc.l    CMPIndY
  2988.         dc.l    OpWrap
  2989.         dc.l    DCPIndY        ;*
  2990.         dc.l    NOPZeroX    ;*
  2991.         dc.l    CMPZeroX
  2992.         dc.l    DECZeroX
  2993.         dc.l    DCPZeroX    ;*
  2994.  
  2995.         dc.l    CLD        ;$d8
  2996.         dc.l    CMPAbsY
  2997.         dc.l    NOPImpl        ;*
  2998.         dc.l    DCPAbsY        ;*
  2999.         dc.l    NOPAbsX        ;*
  3000.         dc.l    CMPAbsX
  3001.         dc.l    DECAbsX
  3002.         dc.l    DCPAbsX        ;*
  3003.  
  3004.         dc.l    CPXImm        ;$e0
  3005.         dc.l    SBCIndX
  3006.         dc.l    NOPZero        ;*
  3007.         dc.l    ISBIndX        ;*
  3008.         dc.l    CPXZero
  3009.         dc.l    SBCZero
  3010.         dc.l    INCZero
  3011.         dc.l    ISBZero        ;*
  3012.  
  3013.         dc.l    INX        ;$e8
  3014.         dc.l    SBCImm
  3015.         dc.l    NOPImpl
  3016.         dc.l    SBCImm        ;*
  3017.         dc.l    CPXAbs
  3018.         dc.l    SBCAbs
  3019.         dc.l    INCAbs
  3020.         dc.l    ISBAbs        ;*
  3021.  
  3022.         dc.l    BEQRel        ;$f0
  3023.         dc.l    SBCIndY
  3024.         dc.l    OpIEC        ;Patch
  3025.         dc.l    ISBIndY        ;*
  3026.         dc.l    NOPZeroX    ;*
  3027.         dc.l    SBCZeroX
  3028.         dc.l    INCZeroX
  3029.         dc.l    ISBZeroX    ;*
  3030.  
  3031.         dc.l    SED        ;$f8
  3032.         dc.l    SBCAbsY
  3033.         dc.l    NOPImpl        ;*
  3034.         dc.l    ISBAbsY        ;*
  3035.         dc.l    NOPAbsX        ;*
  3036.         dc.l    SBCAbsX
  3037.         dc.l    INCAbsX
  3038.         dc.l    ISBAbsX        ;*
  3039.  
  3040.  
  3041. **
  3042. ** Datenbereich
  3043. **
  3044.  
  3045. ; 6510-Task
  3046. CPUProc        dc.l    0    ;Prozess-Handle
  3047. CPUTask        dc.l    0    ;Task des Prozesses
  3048. ReadySet    dc.l    0    ;Signal des Hauptprogramms
  3049. ContinueSet    dc.l    0    ;Signal des CPU-Tasks
  3050. ReadySig    dc.b    0
  3051. ContinueSig    dc.b    0
  3052.  
  3053. ; Emulator-Kennung
  3054. DFFFByte    dc.b    $55    ;Wechselt bei jedem Lesen zwischen $55 und $aa
  3055.  
  3056. ; Interrupt-Flags. Bei einem Interrupt wird eins dieser Flags gesetzt.
  3057. ; Das bewirkt, daß nach dem nächsten Periodic der 6510-Task in die
  3058. ; Routine "HandleInt" springt. Dort werden diese Flags ausgewertet und
  3059. ; entsprechend verzweigt.
  3060.         CNOP    0,4
  3061. Interrupt            ;Zusammenfassung als Langwort
  3062. IntIsRESET    dc.b    0    ;RESET aufgetreten, 6510 beenden oder Pause
  3063. IntIsNMI    dc.b    0    ;NMI aufgetreten
  3064. IntIsIRQ            ;Zusammenfassung als Wort
  3065. IntIsVICIRQ    dc.b    0    ;IRQ durch VIC aufgetreten
  3066. IntIsCIAIRQ    dc.b    0    ;IRQ durch CIA-A aufgetreten
  3067.  
  3068. RESETIsEXIT    dc.b    0    ;Zur Unterscheidung von RESET und EXIT
  3069. RESETIsPause    dc.b    0    ;Zur Unterscheidung von RESET und Pause
  3070.  
  3071.         CNOP    0,4
  3072. RegStore    ds.l    6
  3073.  
  3074. ; Speicherzeiger (außer bei TheChar stimmt bei allen das untere Wort
  3075. ; mit der tatsächlichen C64-Adresse überein, also
  3076. ;  TheRAM   : xxxx0000
  3077. ;  TheBasic : xxxxa000
  3078. ;  TheKernal: xxxxe000
  3079. ;  TheColor : xxxxd800
  3080.         CNOP    0,4
  3081. TheRAM        dc.l    0    ;Zeiger auf C64-RAM (64K)
  3082. TheBasic    dc.l    0    ;Zeiger auf Basic-ROM
  3083. TheKernal    dc.l    0    ;Zeiger auf Kernal-ROM
  3084. TheChar        dc.l    0    ;Zeiger auf Char-ROM
  3085. TheColor    dc.l    0    ;Zeiger auf Farb-RAM
  3086.  
  3087. ; Taglist für CreateNewProc
  3088. ProcTags    dc.l    NP_Entry,CPUTaskProc
  3089.         dc.l    NP_Name,CPUTaskName
  3090.         dc.l    NP_Priority,-1
  3091.         dc.l    0,0
  3092.  
  3093. ; Requester
  3094. IllegalOpReq    dc.l    20,0,0,0,0
  3095. JumpToIOReq    dc.l    20,0,0,0,0
  3096.  
  3097. RequestStream    ds.l    16    ;Argumente
  3098.  
  3099.         SECTION    "BSS",BSS
  3100.  
  3101. ; Sprungtabellen für Speicherzugriff: Ein Eintrag pro Seite
  3102. ; Eine Tabelle für jede der 8 Speicherkonfigurationen
  3103. ReadTab0    ds.l    256
  3104. ReadTab1    ds.l    256
  3105. ReadTab2    ds.l    256
  3106. ReadTab3    ds.l    256
  3107. ReadTab4    ds.l    256
  3108. ReadTab5    ds.l    256
  3109. ReadTab6    ds.l    256
  3110. ReadTab7    ds.l    256
  3111.  
  3112. WriteTab0    ds.l    256
  3113. WriteTab1    ds.l    256
  3114. WriteTab2    ds.l    256
  3115. WriteTab3    ds.l    256
  3116. WriteTab4    ds.l    256
  3117. WriteTab5    ds.l    256
  3118. WriteTab6    ds.l    256
  3119. WriteTab7    ds.l    256
  3120.  
  3121. JumpTab0    ds.l    256
  3122. JumpTab1    ds.l    256
  3123. JumpTab2    ds.l    256
  3124. JumpTab3    ds.l    256
  3125. JumpTab4    ds.l    256
  3126. JumpTab5    ds.l    256
  3127. JumpTab6    ds.l    256
  3128. JumpTab7    ds.l    256
  3129.  
  3130.         END
  3131.